pax_global_header00006660000000000000000000000064127571142740014524gustar00rootroot0000000000000052 comment=aa4ee78f17d8ab826978d2a00559eb06c3267288 python-openflow-1.1.0-alpha2/000077500000000000000000000000001275711427400160405ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/.coveragerc000066400000000000000000000000241275711427400201550ustar00rootroot00000000000000[run] source = pyof python-openflow-1.1.0-alpha2/.gitignore000066400000000000000000000020671275711427400200350ustar00rootroot00000000000000# Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class *.egg-info # C extensions *.so *.swp # Distribution / packaging .Python env/ build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ *.egg-info/ .installed.cfg *.egg # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *,cover .hypothesis/ # Translations *.mo *.pot # Django stuff: *.log local_settings.py # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs/_build/ docs/pyof*.rst # PyBuilder target/ # IPython Notebook .ipynb_checkpoints # pyenv .python-version # celery beat schedule file celerybeat-schedule # dotenv .env # virtualenv venv/ ENV/ # Spyder project settings .spyderproject # Rope project settings .ropeproject python-openflow-1.1.0-alpha2/LICENSE000066400000000000000000000020771275711427400170530ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2016 python-openflow Team Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. python-openflow-1.1.0-alpha2/README.rst000066400000000000000000000056611275711427400175370ustar00rootroot00000000000000Kytos - python-openflow ======================= |Openflow| |Tag| |Release| |Tests| |License| *python-openflow* is a low level library to parse OpenFlow messages. If you want to read an OpenFlow packet from an open socket or send a message to an OpenFlow switch, this is your best friend. The main features are: high performance, latest specification compliance, short learning curve and free software license. This library is part of `Kytos `_ project, a collaborative project between SPRACE (from São Paulo State University, Unesp) and Caltech (California Institute of Technology). *python-openflow* was developed to be used with *Kytos* controller, but feel free to use this simple and intuitive library in another project with another controller. Overview -------- This is just an overview for you to check whether this project fits your needs. For a more detailed documentation, please check the `python-openflow API Reference Manual `_. Usage ^^^^^ For example, see how it is easy to create a feature request message with this library. You can use ipython3 to get the advantages of autocompletion: .. The code in this section is replicated in docs/toc/usage.rst. >>> from pyof.v0x01.controller2switch.features_request import FeaturesRequest >>> request = FeaturesRequest(xid = 100) >>> print(request.header.message_type) Type.OFPT_FEATURES_REQUEST >>> print(request.header.xid) 100 If you need to send this message via socket, call the ``pack()`` method to get its binary representation: .. code:: python >>> binary_msg = request.pack() Installing ^^^^^^^^^^ The easiest way to install is using pip3 (pip for Python 3): .. code:: shell sudo pip3 install python-openflow Support ^^^^^^^ We are available in IRC and there is also a development mailing list. Details are available in the full documentation. Contributing ^^^^^^^^^^^^ Contributions are welcome either by creating issues in GitHub or in the form of pull requests. Before, please, read the contribution and hacking guides in the main documentation. License ^^^^^^^ This software is under *MIT-License*. For more information please read the ``LICENSE`` file. .. |Openflow| image:: https://img.shields.io/badge/Openflow-1.0.0-brightgreen.svg :target: https://www.opennetworking.org/images/stories/downloads/sdn-resources/onf-specifications/openflow/openflow-spec-v1.0.0.pdf .. |Tag| image:: https://img.shields.io/github/tag/kytos/python-openflow.svg :target: https://github.com/kytos/python-openflow/tags .. |Release| image:: https://img.shields.io/github/release/kytos/python-openvpn.svg :target: https://github.com/kytos/python-openflow/releases .. |Tests| image:: http://kytos.io/imgs/tests-status.svg :target: https://github.com/kytos/python-openflow .. |License| image:: https://img.shields.io/github/license/kytos/python-openflow.svg :target: https://github.com/kytos/python-openflow/blob/master/LICENSE python-openflow-1.1.0-alpha2/docs/000077500000000000000000000000001275711427400167705ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/docs/.gitignore000066400000000000000000000000131275711427400207520ustar00rootroot00000000000000python.inv python-openflow-1.1.0-alpha2/docs/Makefile000066400000000000000000000202111275711427400204240ustar00rootroot00000000000000# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = _build # User-friendly check for sphinx-build ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1) $(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don\'t have Sphinx installed, grab it from http://sphinx-doc.org/) endif # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . # the i18n builder cannot share the environment and doctrees with the others I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . default: make clean make html .PHONY: help help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " singlehtml to make a single large HTML file" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " applehelp to make an Apple Help Book" @echo " devhelp to make HTML files and a Devhelp project" @echo " epub to make an epub" @echo " epub3 to make an epub3" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " latexpdf to make LaTeX files and run them through pdflatex" @echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx" @echo " text to make text files" @echo " man to make manual pages" @echo " texinfo to make Texinfo files" @echo " info to make Texinfo files and run them through makeinfo" @echo " gettext to make PO message catalogs" @echo " changes to make an overview of all changed/added/deprecated items" @echo " xml to make Docutils-native XML files" @echo " pseudoxml to make pseudoxml-XML files for display purposes" @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" @echo " coverage to run coverage check of the documentation (if enabled)" @echo " dummy to check syntax errors of document sources" .PHONY: clean clean: rm -rf pyof.* rm -rf $(BUILDDIR)/* .PHONY: html html: sphinx-apidoc -o . ../pyof/ -d10 -M sed -i "/Submodules/,+1d" *.rst $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." .PHONY: dirhtml dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." .PHONY: singlehtml singlehtml: $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml @echo @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." .PHONY: pickle pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle @echo @echo "Build finished; now you can process the pickle files." .PHONY: json json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json @echo @echo "Build finished; now you can process the JSON files." .PHONY: htmlhelp htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in $(BUILDDIR)/htmlhelp." .PHONY: qthelp qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in $(BUILDDIR)/qthelp, like this:" @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/python-openflowlibrary.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/python-openflowlibrary.qhc" .PHONY: applehelp applehelp: $(SPHINXBUILD) -b applehelp $(ALLSPHINXOPTS) $(BUILDDIR)/applehelp @echo @echo "Build finished. The help book is in $(BUILDDIR)/applehelp." @echo "N.B. You won't be able to view it unless you put it in" \ "~/Library/Documentation/Help or install it in your application" \ "bundle." .PHONY: devhelp devhelp: $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp @echo @echo "Build finished." @echo "To view the help file:" @echo "# mkdir -p $$HOME/.local/share/devhelp/python-openflowlibrary" @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/python-openflowlibrary" @echo "# devhelp" .PHONY: epub epub: $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub @echo @echo "Build finished. The epub file is in $(BUILDDIR)/epub." .PHONY: epub3 epub3: $(SPHINXBUILD) -b epub3 $(ALLSPHINXOPTS) $(BUILDDIR)/epub3 @echo @echo "Build finished. The epub3 file is in $(BUILDDIR)/epub3." .PHONY: latex latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." @echo "Run \`make' in that directory to run these through (pdf)latex" \ "(use \`make latexpdf' here to do that automatically)." .PHONY: latexpdf latexpdf: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through pdflatex..." $(MAKE) -C $(BUILDDIR)/latex all-pdf @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." .PHONY: latexpdfja latexpdfja: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through platex and dvipdfmx..." $(MAKE) -C $(BUILDDIR)/latex all-pdf-ja @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." .PHONY: text text: $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text @echo @echo "Build finished. The text files are in $(BUILDDIR)/text." .PHONY: man man: $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man @echo @echo "Build finished. The manual pages are in $(BUILDDIR)/man." .PHONY: texinfo texinfo: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." @echo "Run \`make' in that directory to run these through makeinfo" \ "(use \`make info' here to do that automatically)." .PHONY: info info: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo "Running Texinfo files through makeinfo..." make -C $(BUILDDIR)/texinfo info @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." .PHONY: gettext gettext: $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale @echo @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." .PHONY: changes changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes @echo @echo "The overview file is in $(BUILDDIR)/changes." .PHONY: linkcheck linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." .PHONY: doctest doctest: $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest @echo "Testing of doctests in the sources finished, look at the " \ "results in $(BUILDDIR)/doctest/output.txt." .PHONY: coverage coverage: $(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage @echo "Testing of coverage in the sources finished, look at the " \ "results in $(BUILDDIR)/coverage/python.txt." .PHONY: xml xml: $(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml @echo @echo "Build finished. The XML files are in $(BUILDDIR)/xml." .PHONY: pseudoxml pseudoxml: $(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml @echo @echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml." .PHONY: dummy dummy: $(SPHINXBUILD) -b dummy $(ALLSPHINXOPTS) $(BUILDDIR)/dummy @echo @echo "Build finished. Dummy builder generates no files." livehtml: sphinx-autobuild -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html -z ../pyof python-openflow-1.1.0-alpha2/docs/_static/000077500000000000000000000000001275711427400204165ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/docs/_static/custom.css000066400000000000000000000034451275711427400224500ustar00rootroot00000000000000/* #5d4796 #5f21b7 #352169 #5d64d0 #58488a #4A4090 */ .rst-content dl:not(.docutils) dl.method code.descname { color: #4A4090; } .rst-content dl:not(.docutils) dl dt { margin-bottom: 6px; border: none; border-left: solid 3px #5d4796; background: white; color: #352169; } .rst-content tt.literal, .rst-content tt.literal, .rst-content code.literal { color: #5d4796; } code, .rst-content tt, .rst-content code { white-space: nowrap; max-width: 100%; background: #ebebeb; border: solid 1px #5f21b7; font-size: 75%; padding: 0 5px; font-family: Consolas,"Andale Mono WT","Andale Mono","Lucida Console","Lucida Sans Typewriter","DejaVu Sans Mono","Bitstream Vera Sans Mono","Liberation Mono","Nimbus Mono L",Monaco,"Courier New",Courier,monospace; color: #E74C3C; overflow-x: auto; } .wy-side-nav-search input[type="text"] { border-color: white; } .wy-side-nav-search { background-color: #4A4090; } .wy-nav-top { background: #4A4090; } a { color: #6e5baa; text-decoration: none; } .rst-content dl:not(.docutils) dt { display: inline-block; margin: 6px 0; font-size: 90%; line-height: normal; background: #5d4796; color: rgba(255,255,255, 0.5); border-top: 3px solid #352169; padding: 6px; position: relative; } .rst-content dl:not(.docutils) code.descclassname { display: none; /* background-color: transparent; border: none; padding: 0; font-size: 100% !important; color: #352169; */ } .rst-content dl:not(.docutils) code.descname { background-color: transparent; border: none; padding: 0; font-size: 100% !important; color: white; margin: 0px 5px 0px 0px; } .wy-nav-content { padding: 1.618em 3.236em; height: 100%; max-width: 900px; margin: auto; } python-openflow-1.1.0-alpha2/docs/_static/placeholder000066400000000000000000000000001275711427400226110ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/docs/_templates/000077500000000000000000000000001275711427400211255ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/docs/_templates/placeholder000066400000000000000000000000001275711427400233200ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/docs/conf.py000066400000000000000000000245521275711427400202770ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # python-openflow library documentation build configuration file, created by # sphinx-quickstart on Wed May 11 16:13:35 2016. # # This file is execfile()d with the current directory set to its # containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import sys import os # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. sys.path.insert(0, os.path.abspath('../')) # -- General configuration ------------------------------------------------ # If your documentation needs a minimal Sphinx version, state it here. #needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ 'sphinx.ext.autodoc', 'sphinx.ext.napoleon', 'sphinx.ext.doctest', 'sphinx.ext.intersphinx', 'sphinx.ext.coverage', ] # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix(es) of source filenames. # You can specify multiple suffix as a list of string: # source_suffix = ['.rst', '.md'] source_suffix = '.rst' # The encoding of source files. #source_encoding = 'utf-8-sig' # The master toctree document. master_doc = 'index' # General information about the project. project = u'python-openflow library' copyright = u'2016, Kytos\' Development Team' author = u'Kytos\' Development Team' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = u'0.1.0' # The full version, including alpha/beta/rc tags. release = u'0.1.0' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. # # This is also used if you do content translation via gettext catalogs. # Usually you set "language" from the command line for these cases. language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This patterns also effect to html_static_path and html_extra_path exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] # The reST default role (used for this markup: `text`) to use for all # documents. #default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. # show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # If true, keep warnings as "system message" paragraphs in the built documents. #keep_warnings = False # If true, `todo` and `todoList` produce output, else they produce nothing. todo_include_todos = False # -- Options for HTML output ---------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. #html_theme = 'alabaster' html_theme = 'sphinx_rtd_theme' #html_theme = 'bizstyle' html_context = { 'css_files': ['_static/custom.css'], } # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. #html_theme_options = {} # Add any paths that contain custom themes here, relative to this directory. #html_theme_path = [] # The name for this set of Sphinx documents. # " v documentation" by default. #html_title = u'python-openflow library v0.1.0' # A shorter title for the navigation bar. Default is the same as html_title. #html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. #html_logo = None # The name of an image file (relative to this directory) to use as a favicon of # the docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. #html_favicon = None # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static'] # Add any extra paths that contain custom files (such as robots.txt or # .htaccess) here, relative to this directory. These files are copied # directly to the root of the documentation. #html_extra_path = [] # If not None, a 'Last updated on:' timestamp is inserted at every page # bottom, using the given strftime format. # The empty string is equivalent to '%b %d, %Y'. #html_last_updated_fmt = None # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. #html_domain_indices = True # If false, no index is generated. #html_use_index = True # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. html_show_sourcelink = False # If true, "Created using Sphinx" is shown in the HTML footer. Default is True. #html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. #html_show_copyright = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = None # Language to be used for generating the HTML full-text search index. # Sphinx supports the following languages: # 'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja' # 'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr', 'zh' #html_search_language = 'en' # A dictionary with options for the search language support, empty by default. # 'ja' uses this config value. # 'zh' user can custom change `jieba` dictionary path. #html_search_options = {'type': 'default'} # The name of a javascript file (relative to the configuration directory) that # implements a search results scorer. If empty, the default will be used. #html_search_scorer = 'scorer.js' # Output file base name for HTML help builder. htmlhelp_basename = 'python-openflowlibrarydoc' # -- Options for LaTeX output --------------------------------------------- latex_elements = { # The paper size ('letterpaper' or 'a4paper'). #'papersize': 'letterpaper', # The font size ('10pt', '11pt' or '12pt'). #'pointsize': '10pt', # Additional stuff for the LaTeX preamble. #'preamble': '', # Latex figure (float) alignment #'figure_align': 'htbp', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, # author, documentclass [howto, manual, or own class]). latex_documents = [ (master_doc, 'python-openflowlibrary.tex', u'python-openflow library Documentation', u'Kytos\' Development Team', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. #latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. #latex_use_parts = False # If true, show page references after internal links. #latex_show_pagerefs = False # If true, show URL addresses after external links. #latex_show_urls = False # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_domain_indices = True # -- Options for manual page output --------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ (master_doc, 'python-openflowlibrary', u'python-openflow library Documentation', [author], 1) ] # If true, show URL addresses after external links. #man_show_urls = False # -- Options for Texinfo output ------------------------------------------- # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ (master_doc, 'python-openflowlibrary', u'python-openflow library Documentation', author, 'python-openflowlibrary', 'One line description of project.', 'Miscellaneous'), ] # Documents to append as an appendix to all manuals. #texinfo_appendices = [] # If false, no module index is generated. #texinfo_domain_indices = True # How to display URL addresses: 'footnote', 'no', or 'inline'. #texinfo_show_urls = 'footnote' # If true, do not generate a @detailmenu in the "Top" node's menu. #texinfo_no_detailmenu = False # Example configuration for intersphinx: refer to the Python standard library. # Note: links to Python doc only work if you are online or have python.inv # file. To download it, run: # curl https://docs.python.org/3/objects.inv >python.inv intersphinx_mapping = {'python': ('https://docs.python.org/3', (None, 'python.inv'))} # Napoleon settings from http://www.sphinx-doc.org/en/stable/ext/napoleon.html napoleon_google_docstring = True napoleon_numpy_docstring = False napoleon_include_special_with_doc = False # Sphinx's default # As pylint warns when the public __init__ is not documented (according to a # PEP), we should document __init__ and the option below appends its docstring # to the class'. autoclass_content = 'both' python-openflow-1.1.0-alpha2/docs/index.rst000066400000000000000000000020451275711427400206320ustar00rootroot00000000000000.. include:: ../README.rst Here you will find an extensive documentation of this library. If you wanna fix or improve this documentation, please read our |contrib|_ and feel free to submit a patch on our `doc/` directory. Table of Contents ================= .. toctree:: :maxdepth: 2 toc/introduction toc/install toc/usage toc/CONTRIBUTE toc/HACKING toc/AUTHORS API Reference ------------- .. toctree:: :maxdepth: 9 :titlesonly: :caption: Documentation of classes and methods. :name: mastertoc modules Authors ------- This is a collaborative project between SPRACE (From São Paulo State University, Unesp) and Caltech (California Institute of Technology). For a complete list of authors, please open ``AUTHORS.rst`` file. Indices and tables ------------------ * :ref:`genindex` * :ref:`modindex` * :ref:`search` .. |kytos-site| replace:: Kytos web site .. _kytos-site: http://kytos.io/ .. |contrib| replace:: contributing instructions .. _contrib: https://github.com/kytos/python-openflow/blob/develop/CONTRIBUTE.md python-openflow-1.1.0-alpha2/docs/modules.rst000066400000000000000000000000671275711427400211750ustar00rootroot00000000000000.. toctree:: :maxdepth: 10 :titlesonly: pyof python-openflow-1.1.0-alpha2/docs/toc/000077500000000000000000000000001275711427400175555ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/docs/toc/AUTHORS.rst000066400000000000000000000005411275711427400214340ustar00rootroot00000000000000Authors and Contributors ======================== - Beraldo Leal - Azher Mughal - Artur Baruchi - André Tadeu - Diego Rabatone Oliveira - Raphael Cóbe - Rogerio Iope - Carlos Eduardo Moreira dos Santos This is a collaborative project between SPRACE (From São Paulo State University, Unesp) and Caltech (California Institute of Technology). python-openflow-1.1.0-alpha2/docs/toc/CONTRIBUTE.rst000066400000000000000000000322171275711427400217720ustar00rootroot00000000000000Contributing ============ We'd love for you to contribute to our source code and to make Kytos even better than it is today! Here are the guidelines we follow: - `Got a Question or Problem?`_ - `Found an Issue?`_ - `Want a Feature?`_ - `Want a Doc Fix?`_ - `Submission Guidelines`_ - `Coding Style`_ - `Tests`_ - `Signing the CLA`_ - `Contact Us`_ Got a Question or Problem? -------------------------- If you have questions about how to use any component of Kytos project, please direct these to our dev mailing list. We are also available on IRC. Check the details in the `Contact Us`_ section. Found an Issue? --------------- If you find a bug in the source code or a mistake in the documentation, you can help us by submitting an issue to our `GitHub Repository `__. Even better, you can submit a Pull Request with a fix. **Please see the** `Submission Guidelines`_ **below.** Want a Feature? --------------- You can also request a new feature by submitting an issue to our `GitHub Repository `__. If you would like to implement a new feature, then consider what kind of change it is: - **Major Changes** that you wish to contribute to the project should be discussed first on our `dev mailing list or IRC `_, so that we can better coordinate our efforts, prevent duplication of work, and help you to craft the change so that it is successfully accepted into the project. - **Small Changes** can be crafted and submitted to the `GitHub Repository `__ as a Pull Request. Want a Doc Fix? --------------- Updating Sphinx documentation ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ To change the documentation that is created by Sphinx, in the `docs` folder, follow these instructions: 1. In Python files, use `Google-style docstrings `_ (`Napoleon docs `_ is also a useful resource); 2. To generate the documentation, run `make` inside `docs` folder; 3. Open `docs/_build/html/index.html` in your browser to check the output of your changes; 4. Repeat steps 2 and 3 until you are satisfied with the results (don't forget to refresh the page in the browser); Tips and tricks ~~~~~~~~~~~~~~~ To automatically build the documentation and refresh the browser every time a file is changed: 1. Install the required package: `sudo pip3 install sphinx-autobuild` 2. In the `docs` folder, run `make livehtml` 3. Go to http://127.0.0.1:8000/index.html Check before submitting ~~~~~~~~~~~~~~~~~~~~~~~ Before submitting a doc fix, please, see the section `Checking your code`_. Submission Guidelines --------------------- Submitting an Issue ~~~~~~~~~~~~~~~~~~~ Before you submit your issue, search the archive to check if the issue is already there with an answer. When opening a new issue, please, use the proper tags we provide to identify the version of the release you are using and the type of the issue that is being opened (i.e.: discussion, bugs, etc). It is important to note that these issues will be used as release's cutoff. If your issue appears to be a bug, and hasn't been reported, open a new issue. Help us to maximize the effort we can spend both fixing issues and adding new features by not reporting duplicate issues. The more relevant information you provide, the faster contributors can tackle the issue. Here are some useful information you might be able to provide: - **Check existing issues** for your issue. Duplicating an issue is slower for both parties so search through open and closed issues to see if what you’re running into has been already addressed; - **Be clear** about what your problem is: what was the expected outcome, what happened instead? Detail how someone else can recreate the problem; - **Motivation for or Use Case** - explain why this is a bug for you; - **Include system details** like what library or operating system you’re using and their versions; - **Paste error output** or logs in your issue or in a `Gist `__. When pasting them in the issue, wrap it with three backticks: **\`\`\`** so that it renders nicely, like ``this``; - **Use Tags** Please, remember to tag your issue according to the version and the issue type; - **Steps to reproduce** - please inform all the steps to reproduce the error; - **Related Issues** - has a similar issue been reported before? - **Suggest a Fix** - if you can't fix the bug yourself, perhaps you can point to what might be causing the problem (line of code or commit). For more information about github issues, please read `github's Issues guide `__. Submitting a Pull Request ~~~~~~~~~~~~~~~~~~~~~~~~~ If you’re able to patch the bug or add the feature yourself – fantastic, make a pull request with the code! Be sure you’ve read the documents on contributing, understand the license and have signed our `Contributor License Agreement (CLA) `_. Once you’ve submitted a pull request, the maintainer(s) can easily compare your branch to the existing one and decide whether or not to incorporate (pull in) your changes. All Kytos subproject uses uses the `Semantic Versioning `_ and we follow the `Gitflow Workflow `_. All contributors should create a fork from ``develop`` branch with the feature's name. Once the feature is implemented the contributor should place a pull request to the ``develop`` branch. Before you submit your pull request consider the following guidelines: - Search `GitHub `__ for an open or closed Pull Request that relates to your submission. You don't want to duplicate effort; - Please sign our `CLA `_ before sending pull requests. We cannot accept code without this; - Make your changes in a new git branch, from ``develop`` branch: .. code:: shell git checkout -b my-fix-branch develop - **Include appropriate test cases**; - Follow our `Coding Style`_; - Commit your changes using very good and descriptive commit messages; - Please consider doing atomic commits (small changes in each commit). - Run our test suit to check if anything is broken: .. code:: shell python3 setup.py test - Push your branch to GitHub: .. code:: shell git push origin my-fix-branch - In GitHub, send a pull request to ``python-openflow:develop``. - If we suggest changes then: - Make the required updates. - Re-run the test suite to ensure tests are still passing. - Commit your changes to your branch (e.g. ``my-fix-branch``). - Push the changes to your GitHub repository (this will update your Pull Request). If the PR gets too outdated we may ask you to rebase and force push to update the PR: .. code:: shell git pull git rebase develop -i git push origin my-fix-branch -f *WARNING. Squashing or reverting commits and forced push thereafter may remove GitHub comments on code that were previously made by you and others in your commits.* That's it! Thank you for your contribution! Hot Fix and Security Fix ~~~~~~~~~~~~~~~~~~~~~~~~ To solve important problems like security issues or bugs, we follow a slightly different workflow to make sure the changes can be merged also in the master branch (production code). The contributer should clone the master branch and, after fixing the bug, it has to be merged in both master and develop branch. First clone the master branch as following: .. code:: bash git checkout -b issue-#001 master # Fix the bug git checkout master git merge issue-#001 git push Then, merge the fix to develop branch as well: .. code:: shell git checkout develop git merge issue-#001 git push After your pull request is merged ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ After your pull request is merged, you can safely delete your branch and pull the changes from the main (upstream) repository: - Delete the remote branch on GitHub either through the GitHub web UI or your local shell as follows: .. code:: shell git push origin --delete my-fix-branch - Check out the ``develop`` branch: .. code:: shell git checkout develop -f - Delete the local branch: .. code:: shell git branch -D my-fix-branch - If you haven't done it yet, add the ``upstream`` repository (only once): .. code:: shell git remote add upstream https://github.com/kytos/python-openflow.git git remote # you should now see origin and upstream - Update your ``develop`` with the latest upstream version: .. code:: shell git pull upstream develop Information about environment setup for developers can be found in the :doc:`HACKING` section. Pull Request Pro Tips ~~~~~~~~~~~~~~~~~~~~~ - **`Fork `__ the repository** and clone it locally. Connect your local repository to the original ‘upstream’ one by adding it as a remote. **Pull in** changes from ‘upstream’ often to stay up to date so that when you submit your pull request, merge conflicts will be less likely. See more detailed instructions `here `__. - **Create a `branch `__** for your edits. - **Be clear** about what problem is occurring and how someone can recreate that problem or why your feature will help. Then be equally as clear about the steps you took to make your changes. - **It’s best to test**. Run your changes against any existing tests if they exist and create new ones when needed, trying to cover all your code. Whether tests exist or not, make sure your changes don’t break the existing project. - **Contribute using the project style** to the best of your abilities. This may mean using indents, semi colons or comments differently than you would in your own repository, but makes it easier for the maintainer to merge, others to understand and maintain it in the future. Open Pull Requests ~~~~~~~~~~~~~~~~~~ Once you’ve opened a pull request, a discussion will start around your proposed changes. Other contributors and users may chime in, but ultimately the decision is made by the maintainer(s). You may be asked to make some changes to your pull request. If so, add more commits to your branch and push them – they’ll automatically go into the existing pull request. If your pull request is merged – great! If it is not, no sweat, it may not be what the project maintainer had in mind, or they were already working on it. This happens, so our recommendation is to take any feedback you’ve received and go forth and pull request again – or create your own open source project starting with the forked repository. Code contribution steps review: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - Fork the project & clone locally - Create an upstream remote and sync your local copy before you branch - Branch for each separate piece of work - Do the work, write good commit messages, and follow the project coding style - Push to your origin repository - Create a new PR in GitHub - Respond to any code review feedback Coding style ------------ Code ~~~~ We follow `PEP8 `_, `PEP20 `_ and, as a short resume, `The Best of the Best Practices (BOBP) Guide for Python `_. Documentation ~~~~~~~~~~~~~ For documentation, we follow pydocstyle (PEP257) and use Google-style docstrings. More information about Google-style docstrings can be found in the `Updating Sphinx documentation`_ section. Checking your code ~~~~~~~~~~~~~~~~~~ We provide a setuptools command to check the style and also look for bugs in the code. Make sure you don't add errors to the output of (in root folder): .. code:: shell python3 setup.py lint During development, you may prefer the faster version below. If you do, run the command above at least in the end, before submitting your contribution, to check for additional problems. .. code:: shell python3 setup.py quick_lint Tests ----- This project tries to follow the TDD (Test Driven Development) process. Before writing code to contribute, write the tests related to the functionality you wish to implement and then write the code to pass this test. More info about the tests can be found in the :doc:`HACKING` section. Use the raw packet files ~~~~~~~~~~~~~~~~~~~~~~~~ We provide some files with raw packets to be used as input with the parser library. Use theses files to test your features. To use our raw packet files, please take a look inside ``raw`` directory. Signing the CLA --------------- Please sign our Contributor License Agreement (CLA) before sending pull requests. For any code changes to be accepted, the CLA must be signed. It's a quick process, we promise! Contact Us ---------- You can find us on the **#of-ng** IRC channel on **freenode.net** network. There is also our dev mailing list: **of-ng-dev** (at) **ncc** (dot) **unesp** (dot) **br** python-openflow-1.1.0-alpha2/docs/toc/HACKING.rst000066400000000000000000000105151275711427400213550ustar00rootroot00000000000000Hacking ======= Before reading this file, please read the :doc:`CONTRIBUTE` section that contains the main guidelines of the project. Development Environment Setup ----------------------------- This project is written in Python (version 3.5). You need to add the pyof folder, located in this repository root, to your PYTHONPATH environment variable. For that, you have to execute the following on the command line (while in the repository root folder): .. code:: shell export PYTHONPATH=`pwd`/ofp:$PYTHONPATH Remember that every time you start a new shell instance you will have to repeat the command above, since this is an environment variable. To have it executed automatically in every shell, add it to ``~/.bashrc`` replacing ``pwd`` by the full path of the repository (output of ``pwd``). Virtualenv ~~~~~~~~~~ Another option is to use *virtualenv*. It installs the required and recommended python libraries without messing up with your system. Besides, you don't need to manually change the PYTHONPATH variable. To install it, run the following commands: .. code:: shell sudo apt install python3-pip sudo pip3 install virtualenv virtualenvwrapper If you are working with **bash**, add the following lines on your ``~/.bash_profile`` or ``~/.bashrc`` to setup *virtualenvwrapper*: .. code:: shell export WORKON_HOME=~/.virtualenvs source /usr/local/bin/virtualenvwrapper.sh If you are using `oh-my-zsh `__, you can just add the *virtualenvwrapper* plugin to your plugins list (inside ``~/.zshrc``). This plugin will: - Load Python's `virtualenvwrapper shell tools `__; - Automatically activate virtualenv when ``cd``'ing into git repository with a matching name. We also recommend adding the bellow code to your ``~/.virtualenvs/postmkvirtualenv`` file: .. code:: shell echo '_OLD_PYTHONPATH="$PYTHONPATH"' >> ~/.virtualenvs/"${PWD##*/}"/bin/postactivate echo "PYTHONPATH="'"'$(pwd)'"' >> ~/.virtualenvs/"${PWD##*/}"/bin/postactivate echo 'PYTHONPATH="$_OLD_PYTHONPATH"' >> ~/.virtualenvs/"${PWD##*/}"/bin/postdeactivate This will change the PYTHONPATH environment variable to your projects path when the virtualenv is activated. After installed, clone this repository locally, ``cd`` into it and create the required virtualenv with the same name as the repository directory: .. code:: shell mkvirtualenv "${PWD##*/}" -r requirements-dev.txt This will create the virtualenv with all project requirements and also activate it. The standard setup finishes here. If you are using ``oh-my-zsh`` plugin then every time you enter on the project directory, the virtualenvironment will be automaticaly loaded. If you are using bash, then you need to run the ``workon`` command to activate the environment: .. code:: shell workon python-openflow See more virtualenvwrapper commands on: http://virtualenvwrapper.readthedocs.org/en/latest/command_ref.html Virtualenv Extras ^^^^^^^^^^^^^^^^^ If you want to show the current activated virtualenv on the right side of your shell, add the following code to your ``~/.virtualenvs/postactivate`` file: .. code:: shell PS1="$_OLD_VIRTUAL_PS1" _OLD_RPROMPT="$RPROMPT" RPROMPT="%{${fg_bold[white]}%}(env: %{${fg[white]}%}`basename \"$VIRTUAL_ENV\"`%{${fg_bold[white]}%})%{${reset_color}%} $RPROMPT" Change the colors to your own preferences. and also this code to your ``~/.virtualenvs/postdeactivate`` file: .. code:: shell RPROMPT="$_OLD_RPROMPT" TDD (Test Driven Development) ----------------------------- We aim at 100% of test coverage. We are using Python `unittest `__ to write tests and `coverage.py `__ for coverage metrics. To install the coverage (python3 version), run: .. code:: shell pip3 install coverage To run the tests, use the following command on the root folder of the project: .. code:: shell python3 setup.py test To run check the code test coverage, first run: .. code:: shell coverage run setup.py test To see the command line report run the command ``coverage report`` and, to generate a HTML report, run: ``coverage html`` and open the file **html\_cov/index.html** into your browser (you can run ``open html_cov/index.html``). python-openflow-1.1.0-alpha2/docs/toc/install.rst000066400000000000000000000026201275711427400217550ustar00rootroot00000000000000Installation ============ This library was built to run on Unix-like distributions. You need at least `python3` as a dependency. We also make use of `setuptools` to ease the installation process. You can install this package with pip package installer or from source code. Installing from PyPI -------------------- *python-openflow* is in PyPI, so you can easily install it via `pip3` (`pip` for Python 3) and also include this project in your `requirements.txt` (don't worry if you don't recognize this file). If you do not have `pip3` you can install it on Ubuntu-base machines by running: .. code-block:: shell $ sudo add-apt-repository universe $ sudo apt update $ sudo apt install python3-pip Once you have `pip3`, execute: .. code-block:: shell $ sudo pip3 install python-openflow Installing from source/git -------------------------- First you need to clone `python-openflow` repository: .. code-block:: shell $ git clone https://github.com/kytos/python-openflow.git After cloning, the installation process is done by `setuptools` in the usual way: .. code-block:: shell $ cd python-openflow $ sudo python3 setup.py install Checking installation --------------------- That's it! To check wether it is installed successfully, please try to import after running ``python3`` or ``ipython3``: .. code-block:: python3 >>> import pyof >>> # no errors should be displayed python-openflow-1.1.0-alpha2/docs/toc/introduction.rst000066400000000000000000000056251275711427400230400ustar00rootroot00000000000000Introduction ============ Our main goal is to make the development of OpenFlow applications easy and straightforward. This library is the foundation for the development of any OpenFlow application. If you have read the OpenFlow specification, the learning curve for using this library will be minimal. We tried to keep it very close to the specs regarding class names and attributes. Source code structure --------------------- This project is packed as a python package (``python-openflow``), and contains the following directory structure: * ``pyof/``: contains all the implemented versions of the OpenFlow Protocol Parser: * Each version has its own folder; * Each version inherits from previous version using OOP techniques. So when a new protocol version is released, we implement only the changes and new code; * ``docs/``: We use sphinx_ to document our code, including this page that you are reading. On this directory we save only the ``.rst`` files and documentation source code; * ``tests/``: Here we use unit tests to keep our code working with automatic checks. Each OpenFlow version has its own unittest suit below its directory; * ``raw/``: raw (binary) OpenFlow Messages, dumped with tcpdump_ used for testing purposes. Main Highlights --------------- Speed focused ~~~~~~~~~~~~~ We keep the word *performance* in mind since the beginning of the development. Also, as computer scientists, we will always try to get the best performance by using the most suitable algorithms. Some of our developers participated in several demonstrations involving tests with high-speed networks (~1 terabit/s), some even involving data transfers from/to CERN. Always updated ~~~~~~~~~~~~~~ To avoid code repetition this project utilizes an incremental architecture. This means that the first version (1.0.0 = v0x01) was coded from the full OpenFlow 1.0.2 Protocol. The 1.1 version (v0x02) imports the 1.0 version and then do the necessary changes to make it compatible with the OpenFlow 1.1.0 Protocol, and the next version follows the same logic. Using incremental code makes the implementation of new versions of OpenFlow protocol faster. Our main goal is to follow the specifications since the very beginning. Easy to learn ~~~~~~~~~~~~~ Python is an easy language to learn and we aim at writing code in a "pythonic way". We also provide a well documented API. Thus, learning to make your controller using this library is a trivial task. Born to be free ~~~~~~~~~~~~~~~ OpenFlow was born with a simple idea: make your network more vendor agnostic and we like that! We are advocates and supporters of free software and we believe that the more eyes observe the code, the better it will be. This project can receive support from many vendors, but will never follow a particular vendor direction. *python-openflow* will always be free software. .. _sphinx: http://sphinx.pocoo.org/ .. _tcpdump: http://www.tcpdump.org/ python-openflow-1.1.0-alpha2/docs/toc/usage.rst000066400000000000000000000013231275711427400214120ustar00rootroot00000000000000Usage ===== The main goal of this library is to provide a very simple and intuitive syntax to parse OpenFlow packets. As we support multiple OpenFlow versions, you need to be specific on which version to import. Parsing a message ----------------- Creating a message ------------------ For example, let's create a feature request message. Tip: you can use ipython3 for autocompletion: .. The code in this section is replicated in README.rst. >>> from pyof.v0x01.controller2switch.features_request import FeaturesRequest >>> request = FeaturesRequest(xid = 100) >>> print(request.header.message_type) Type.OFPT_FEATURES_REQUEST >>> print(request.header.xid) 100 A simple controller example --------------------------- python-openflow-1.1.0-alpha2/pyof/000077500000000000000000000000001275711427400170155ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/pyof/__init__.py000066400000000000000000000003051275711427400211240ustar00rootroot00000000000000"""The ofx parser package. A package to parse OpenFlow messages. This package is a library that parses and creates OpenFlow Messages. It contains all implemented versions of OpenFlow protocol """ python-openflow-1.1.0-alpha2/pyof/v0x01/000077500000000000000000000000001275711427400176735ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/pyof/v0x01/__init__.py000066400000000000000000000000721275711427400220030ustar00rootroot00000000000000"""The ofx parser package - spec version 0x01 (1.0.0).""" python-openflow-1.1.0-alpha2/pyof/v0x01/asynchronous/000077500000000000000000000000001275711427400224265ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/pyof/v0x01/asynchronous/__init__.py000066400000000000000000000000351275711427400245350ustar00rootroot00000000000000"""Asynchronous messages.""" python-openflow-1.1.0-alpha2/pyof/v0x01/asynchronous/error_msg.py000066400000000000000000000122511275711427400250000ustar00rootroot00000000000000"""Defines an Error Message.""" # System imports from enum import Enum from pyof.v0x01.common.header import Header, Type from pyof.v0x01.foundation import exceptions from pyof.v0x01.foundation.base import GenericMessage from pyof.v0x01.foundation.basic_types import ConstantTypeList, UBInt16 # Third-party imports __all__ = ('ErrorMsg', 'ErrorType', 'BadActionCode', 'BadRequestCode', 'FlowModFailedCode', 'HelloFailedCode', 'PortModFailedCode', 'QueueOpFailedCode') # Enums class ErrorType(Enum): """Values for ’type’ in ofp_error_message. These values are immutable: they will not change in future versions of the protocol (although new values may be added). """ #: Hello protocol failed OFPET_HELLO_FAILED = 0, #: Request was not understood OFPET_BAD_REQUEST = 1, #: Error in action description OFPET_BAD_ACTION = 2, #: Problem in modifying Flow entry OFPET_FLOW_MOD_FAILED = 3, #: Problem in modifying Port entry OFPET_PORT_MOD_FAILED = 4, #: Problem in modifying Queue entry OFPET_QUEUE_OP_FAILED = 5 class HelloFailedCode(Enum): """Error_msg 'code' values for OFPET_HELLO_FAILED. 'data' contains an ASCII text string that may give failure details. """ #: No compatible version OFPHFC_INCOMPATIBLE = 0, #: Permissions error OFPHFC_EPERM = 1 class BadRequestCode(Enum): """Error_msg 'code' values for OFPET_BAD_REQUEST. 'data' contains at least the first 64 bytes of the failed request. """ #: ofp_header.version not supported. OFPBRC_BAD_VERSION = 0 #: ofp_header.type not supported. OFPBRC_BAD_TYPE = 1 #: ofp_stats_request.type not supported. OFPBRC_BAD_STAT = 2 #: Vendor not supported (in ofp_vendor_header or ofp_stats_request or #: ofp_stats_reply). OFPBRC_BAD_VENDOR = 3 #: Vendor subtype not supported. OFPBRC_BAD_SUBTYPE = 4 #: Permissions error. OFPBRC_EPERM = 5 #: Wrong request length for type. OFPBRC_BAD_LEN = 6 #: Specified buffer has already been used. OFPBRC_BUFFER_EMPTY = 7 #: Specified buffer does not exist. OFPBRC_BUFFER_UNKNOWN = 8 class BadActionCode(Enum): """Error_msg 'code' values for OFPET_BAD_ACTION. 'data' contains at least the first 64 bytes of the failed request. """ #: Unknown action type OFPBAC_BAD_TYPE = 0, #: Length problem in actions OFPBAC_BAD_LEN = 1, #: Unknown vendor id specified OFPBAC_BAD_VENDOR = 2, #: Unknown action type for vendor id OFPBAC_BAD_VENDOR_TYPE = 3, #: Problem validating output action OFPBAC_BAD_OUT_PORT = 4, #: Bad action argument OFPBAC_BAD_ARGUMENT = 5, #: Permissions error OFPBAC_EPERM = 6, #: Can’t handle this many actions OFPBAC_TOO_MANY = 7, #: Problem validating output queue OFPBAC_BAD_QUEUE = 8 class FlowModFailedCode(Enum): """Error_msg 'code' values for OFPET_FLOW_MOD_FAILED. 'data' contains at least the first 64 bytes of the failed request. """ #: Flow not added because of full tables OFPFMFC_ALL_TABLES_FULL = 0 #: Attempted to add overlapping flow with CHECK_OVERLAP flag set OFPFMFC_OVERLAP = 1 #: Permissions error OFPFMFC_EPERM = 2 #: Flow not added because of non-zero idle/hard timeout OFPFMFC_BAD_EMERG_TIMEOUT = 3 #: Unknown command OFPFMFC_BAD_COMMAND = 4 #: Unsupported action list - cannot process in the order specified OFPFMFC_UNSUPPORTED = 5 class PortModFailedCode(Enum): """Error_msg 'code' values for OFPET_PORT_MOD_FAILED. 'data' contains at least the first 64 bytes of the failed request. """ #: Specified port does not exist OFPPMFC_BAD_PORT = 0, #: Specified hardware address is wrong OFPPMFC_BAD_HW_ADDR = 1 class QueueOpFailedCode(Enum): """Error msg 'code' values for OFPET_QUEUE_OP_FAILED. 'data' contains at least the first 64 bytes of the failed request. """ #: Invalid port (or port does not exist) OFPQOFC_BAD_PORT = 0, #: Queue does not exist OFPQOFC_BAD_QUEUE = 1, #: Permissions error OFPQOFC_EPERM = 2 # Classes class ErrorMsg(GenericMessage): """OpenFlow Error Message. This message does not contain a body in addition to the OpenFlow Header. """ #: :class:`~.header.Header`: OpenFlow Header header = Header(message_type=Type.OFPT_ERROR) error_type = UBInt16(enum_ref=ErrorType) code = UBInt16() data = ConstantTypeList() def __init__(self, xid=None, error_type=None, code=None, data=None): """Assign parameters to object attributes. Args: xid (int): To be included in the message header. error_type (ErrorType): Error type. code (Enum): Error code. data: Its content is specified in the error code documentation. """ super().__init__(xid) self.error_type = error_type self.code = code self.data = [] if data is None else data def unpack(self, buff, offset=0): """Unpack binary data into python object.""" raise exceptions.MethodNotImplemented("'Unpack' method not " "implemented on ErrorMsg class") python-openflow-1.1.0-alpha2/pyof/v0x01/asynchronous/flow_removed.py000066400000000000000000000050711275711427400254730ustar00rootroot00000000000000"""The controller has requested to be notified when flows time out.""" # System imports from enum import Enum # Local source tree imports from pyof.v0x01.common.flow_match import Match from pyof.v0x01.common.header import Header, Type from pyof.v0x01.foundation.base import GenericMessage from pyof.v0x01.foundation.basic_types import (PAD, UBInt8, UBInt16, UBInt32, UBInt64) __all__ = ('FlowRemoved', 'FlowRemovedReason') # Enums class FlowRemovedReason(Enum): """Why the flow was removed.""" #: Flow idle time exceeded idle_timeout OFPRR_IDLE_TIMEOUT = 0 #: Time exceeded hard_timeout OFPRR_HARD_TIMEOUT = 1 #: Evicted by a DELETE flow mod OFPRR_DELETE = 2 # Classes class FlowRemoved(GenericMessage): """Flow removed (datapath -> controller).""" #: :class:`~.header.Header`: OpenFlow Header header = Header(message_type=Type.OFPT_FLOW_REMOVED) #: :class:`~.flow_match.Match`: OpenFlow Header match = Match() cookie = UBInt64() priority = UBInt16() reason = UBInt8(enum_ref=FlowRemovedReason) #: Align to 32-bits. pad = PAD(1) duration_sec = UBInt32() duration_nsec = UBInt32() idle_timeout = UBInt16() #: Align to 64-bits. pad2 = PAD(2) packet_count = UBInt64() byte_count = UBInt64() def __init__(self, xid=None, match=None, cookie=None, priority=None, reason=None, duration_sec=None, duration_nsec=None, idle_timeout=None, packet_count=None, byte_count=None): """Assign parameters to object attributes. Args: xid (int): OpenFlow Header's xid. match (Match): Fields' description. cookie (int): Opaque controller-issued identifier. priority (int): Priority level of flow entry. reason (FlowRemovedReason): Why the flow was removed. duration_sec (int): Time the flow was alive in seconds. duration_nsec (int): Time the flow was alive in nanoseconds in addition to duration_sec. idle_timeout (int): Idle timeout from original flow mod. packet_count (int): Number of packets. byte_count (int): Byte count. """ super().__init__(xid) self.match = match self.cookie = cookie self.priority = priority self.reason = reason self.duration_sec = duration_sec self.duration_nsec = duration_nsec self.idle_timeout = idle_timeout self.packet_count = packet_count self.byte_count = byte_count python-openflow-1.1.0-alpha2/pyof/v0x01/asynchronous/packet_in.py000066400000000000000000000037571275711427400247510ustar00rootroot00000000000000"""For packets received by the datapath and sent to the controller.""" # System imports from enum import Enum from pyof.v0x01.common.header import Header, Type from pyof.v0x01.foundation.base import GenericMessage from pyof.v0x01.foundation.basic_types import (PAD, BinaryData, UBInt8, UBInt16, UBInt32) # Third-party imports __all__ = ('PacketIn', 'PacketInReason') # Enums class PacketInReason(Enum): """Reason why this packet is being sent to the controller.""" #: No matching flow OFPR_NO_MATCH = 0 #: Action explicitly output to controller OFPR_ACTION = 1 # Classes class PacketIn(GenericMessage): """Packet received on port (datapath -> controller).""" #: :class:`~.header.Header`: OpenFlow Header header = Header(message_type=Type.OFPT_PACKET_IN) buffer_id = UBInt32() total_len = UBInt16() in_port = UBInt16() reason = UBInt8(enum_ref=PacketInReason) #: Align to 32-bits. pad = PAD(1) data = BinaryData() def __init__(self, xid=None, buffer_id=None, total_len=None, in_port=None, reason=None, data=b''): """Assign parameters to object attributes. Args: xid (int): Header's xid. buffer_id (int): ID assigned by datapath. total_len (int): Full length of frame. in_port (int): Port on which frame was received. reason (PacketInReason): The reason why the packet is being sent data (bytes): Ethernet frame, halfway through 32-bit word, so the IP header is 32-bit aligned. The amount of data is inferred from the length field in the header. Because of padding, offsetof(struct ofp_packet_in, data) == sizeof(struct ofp_packet_in) - 2. """ super().__init__(xid) self.buffer_id = buffer_id self.total_len = total_len self.in_port = in_port self.reason = reason self.data = data python-openflow-1.1.0-alpha2/pyof/v0x01/asynchronous/port_status.py000066400000000000000000000024261275711427400253730ustar00rootroot00000000000000"""Defines an Error Message.""" # System imports from enum import Enum # Local source tree imports from pyof.v0x01.common.header import Header, Type from pyof.v0x01.common.phy_port import PhyPort from pyof.v0x01.foundation.base import GenericMessage from pyof.v0x01.foundation.basic_types import PAD, UBInt8 # Third-party imports __all__ = ('PortStatus', 'PortReason') # Enums class PortReason(Enum): """What changed about the physical port.""" #: The port was added OFPPR_ADD = 0 #: The port was removed OFPPR_DELETE = 1 #: Some attribute of the port has changed OFPPR_MODIFY = 2 # Classes class PortStatus(GenericMessage): """A physical port has changed in the datapath.""" #: :class:`~.header.Header`: OpenFlow Header header = Header(message_type=Type.OFPT_PORT_STATUS) reason = UBInt8(enum_ref=PortReason) #: Align to 32-bits. pad = PAD(7) desc = PhyPort() def __init__(self, xid=None, reason=None, desc=None): """Assign parameters to object attributes. Args: xid (int): Header's xid. reason (PortReason): Addition, deletion or modification. desc (PhyPort): Port description. """ super().__init__(xid) self.reason = reason self.desc = desc python-openflow-1.1.0-alpha2/pyof/v0x01/common/000077500000000000000000000000001275711427400211635ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/pyof/v0x01/common/__init__.py000066400000000000000000000000631275711427400232730ustar00rootroot00000000000000"""Common structures used on OpenFlow Protocol.""" python-openflow-1.1.0-alpha2/pyof/v0x01/common/action.py000066400000000000000000000207361275711427400230220ustar00rootroot00000000000000"""Defines actions that may be associated with flows packets.""" # System imports from enum import Enum # Local source tree imports from pyof.v0x01.foundation.base import GenericBitMask, GenericStruct from pyof.v0x01.foundation.basic_types import (PAD, HWAddress, UBInt8, UBInt16, UBInt32) # Third-party imports __all__ = ('ActionType', 'ActionHeader', 'ActionOutput', 'ActionEnqueue', 'ActionVlanVid', 'ActionVlanPCP', 'ActionDLAddr', 'ActionNWAddr', 'ActionNWTos', 'ActionTPPort', 'ActionVendorHeader') # Enums class ActionType(GenericBitMask): """Actions associated with flows and packets.""" #: Output to switch port. OFPAT_OUTPUT = 0 #: Set the 802.1q VLAN id. OFPAT_SET_VLAN_VID = 1 #: Set the 802.1q priority. OFPAT_SET_VLAN_PCP = 2 #: Strip the 802.1q header. OFPAT_STRIP_VLAN = 3 #: Ethernet source address. OFPAT_SET_DL_SRC = 4 #: Ethernet destination address. OFPAT_SET_DL_DST = 5 #: IP source address. OFPAT_SET_NW_SRC = 6 #: IP destination address. OFPAT_SET_NW_DST = 7 #: IP ToS (DSCP field, 6 bits). OFPAT_SET_NW_TOS = 8 #: TCP/UDP source port. OFPAT_SET_TP_SRC = 9 #: TCP/UDP destination port. OFPAT_SET_TP_DST = 10 #: Output to queue. OFPAT_ENQUEUE = 11 #: Vendor specific. OFPAT_VENDOR = 0xffff # Classes class ActionHeader(GenericStruct): """Defines the Header that is common to all actions.""" action_type = UBInt16(enum_ref=ActionType) length = UBInt16() #: Pad for 64-bit alignment. pad = PAD(4) def __init__(self, action_type=None, length=None): """The following constructor parameters are optional. Args: action_type (ActionType): The type of the action. length (int): Length of action, including this header. """ super().__init__() self.action_type = action_type self.length = length class ActionOutput(GenericStruct): """Defines the actions output. Action structure for :attr:`ActionType.OFPAT_OUTPUT`, which sends packets out :attr:`port`. When the :attr:`port` is the :attr:`.Port.OFPP_CONTROLLER`, :attr:`max_length` indicates the max number of bytes to send. A :attr:`max_length` of zero means no bytes of the packet should be sent. """ type = UBInt16(ActionType.OFPAT_OUTPUT, enum_ref=ActionType) length = UBInt16(8) port = UBInt16() max_length = UBInt16() def __init__(self, port=None, max_length=None): """The following constructor parameters are optional. Args: port (:class:`Port` or :class:`int`): Output port. max_length (int): Max length to send to controller. """ super().__init__() self.port = port self.max_length = max_length class ActionEnqueue(GenericStruct): """Send packets to a queue's port. A switch may support only queues that are tied to specific PCP/TOS bits. In that case, we cannot map an arbitrary flow to a specific queue, therefore the action ENQUEUE is not supported. The user can still use these queues and map flows to them by setting the relevant fields (TOS, VLAN PCP). """ type = UBInt16(ActionType.OFPAT_ENQUEUE, enum_ref=ActionType) length = UBInt16(16) port = UBInt16() #: Pad for 64-bit alignment. pad = PAD(6) queue_id = UBInt32() def __init__(self, port=None, queue_id=None): """The following constructor parameters are optional. Args: port (physical port or :attr:`.Port.OFPP_IN_PORT`): Queue's port. queue_id (int): Where to enqueue the packets. """ super().__init__() self.port = port self.queue_id = queue_id class ActionVlanVid(GenericStruct): """Action structure for :attr:`ActionType.OFPAT_SET_VLAN_VID`. .. note:: The vlan_vid field is 16 bits long, when an actual VLAN id is only 12 bits. The value 0xffff is used to indicate that no VLAN id was set """ type = UBInt16(ActionType.OFPAT_SET_VLAN_PCP, enum_ref=ActionType) length = UBInt16(8) vlan_id = UBInt16() #: Pad for bit alignment. pad2 = PAD(2) def __init__(self, vlan_id=None): """The following constructor parameters are optional. Args: vlan_id (int): VLAN priority. """ super().__init__() self.vlan_id = vlan_id class ActionVlanPCP(GenericStruct): """Action structure for :attr:`ActionType.OFPAT_SET_VLAN_PCP`.""" type = UBInt16(ActionType.OFPAT_SET_VLAN_PCP, enum_ref=ActionType) length = UBInt16(8) vlan_pcp = UBInt8() #: Pad for bit alignment. pad = PAD(3) def __init__(self, vlan_pcp=None): """The following constructor parameters are optional. Args: vlan_pcp (int): VLAN Priority. .. note:: The vlan_pcp field is 8 bits long, but only the lower 3 bits have meaning. """ super().__init__() self.vlan_pcp = vlan_pcp class ActionDLAddr(GenericStruct): """Action structure for :attr:`ActionType.OFPAT_SET_DL_SRC` or _DST.""" dl_addr_type = UBInt16(enum_ref=ActionType) length = UBInt16(16) dl_addr = HWAddress() #: Pad for bit alignment. pad = PAD(6) def __init__(self, dl_addr_type=None, dl_addr=None): """The following constructor parameters are optional. Args: dl_addr_type (ActionType): :attr:`~ActionType.OFPAT_SET_DL_SRC` or :attr:`~ActionType.OFPAT_SET_DL_DST`. dl_addr (:class:`~.HWAddress`): Ethernet address. Defaults to None. """ super().__init__() self.dl_addr_type = dl_addr_type self.dl_addr = dl_addr class ActionNWAddr(GenericStruct): """Action structure for :attr:`ActionType.OFPAT_SET_NW_SRC` or _DST.""" nw_addr_type = UBInt16(enum_ref=ActionType) length = UBInt16(8) nw_addr = UBInt32() def __init__(self, nw_addr_type=None, nw_addr=None): """The following constructor parameters are optional. Args: nw_addr_type (ActionType): :attr:`~ActionType.OFPAT_SET_NW_SRC` or :attr:`~ActionType.OFPAT_SET_NW_DST`. nw_addr (int): IP Address. """ super().__init__() self.nw_addr_type = nw_addr_type self.nw_addr = nw_addr class ActionNWTos(GenericStruct): """Action structure for :attr:`ActionType.OFPAT_SET_NW_TOS`. .. note:: The nw_tos field is the 6 upper bits of the ToS field to set, in the original bit positions (shifted to the left by 2). """ nw_tos_type = UBInt16(enum_ref=ActionType) length = UBInt16(8) nw_tos = UBInt8() #: Pad for bit alignment. pad = PAD(3) def __init__(self, nw_tos_type=None, nw_tos=None): """The following constructor parameters are optional. Args: nw_tos_type (ActionType): :attr:`~ActionType.OFPAT_SET_NW_SRC` or :attr:`~ActionType.OFPAT_SET_NW_SRC`. nw_tos (int): IP ToS (DSCP field, 6 bits). """ super().__init__() self.nw_tos_type = nw_tos_type self.nw_tos = nw_tos class ActionTPPort(GenericStruct): """Action structure for :attr:`ActionType.OFPAT_SET_TP_SRC` or _DST.""" tp_port_type = UBInt16(enum_ref=ActionType) length = UBInt16(8) tp_port = UBInt16() #: Pad for bit alignment. pad = PAD(2) def __init__(self, tp_port_type=None, tp_port=None): """The following constructor parameters are optional. Args: tp_port_type (ActionType): :attr:`~ActionType.OFPAT_SET_TP_SRC` or :attr:`~ActionType.OFPAT_SET_TP_DST`. tp_port (int): TCP/UDP/other port to set. """ super().__init__() self.tp_port_type = tp_port_type self.tp_port = tp_port class ActionVendorHeader(GenericStruct): """Action header for :attr:`ActionType.OFPAT_VENDOR`. The rest of the body is vendor-defined. """ type = UBInt16(ActionType.OFPAT_VENDOR, enum_ref=ActionType) length = UBInt16() vendor = UBInt32() def __init__(self, length=None, vendor=None): """The following constructor parameters are optional. Args: length (int): Length is a multiple of 8. vender (int): Vendor ID with the same form as in VendorHeader. Defaults to None. """ super().__init__() self.length = length self.vendor = vendor python-openflow-1.1.0-alpha2/pyof/v0x01/common/flow_match.py000066400000000000000000000074671275711427400236760ustar00rootroot00000000000000"""Defines flow statistics structures and related items.""" # System imports # Third-party imports # Local source tree imports from pyof.v0x01.foundation.base import (GenericBitMask, GenericMessage, GenericStruct) from pyof.v0x01.foundation.basic_types import (PAD, HWAddress, UBInt8, UBInt16, UBInt32) __all__ = ('Match', 'FlowWildCards') class FlowWildCards(GenericBitMask): """Wildcards used to identify flows. ``OFPFW_NW_SRC_*``: IP source address wildcard bit count. 0 is exact match, 1 ignores the LSB, 2 ignores the 2 least-significant bits, ..., 32 and higher wildcard the entire field. This is the *opposite* of the usual convention where e.g. /24 indicates that 8 bits (not 24 bits) are wildcarded. ``OFPFW_NW_DST_*``: IP destination address wildcard bit count. Same format as source. """ #: Switch input port. OFPFW_IN_PORT = 1 << 0 #: VLAN id. OFPFW_DL_VLAN = 1 << 1 #: Ethernet source address. OFPFW_DL_SRC = 1 << 2 #: Ethernet destination address. OFPFW_DL_DST = 1 << 3 #: Ethernet frame type. OFPFW_DL_TYPE = 1 << 4 #: IP protocol. OFPFW_NW_PROTO = 1 << 5 #: TCP/UDP source port. OFPFW_TP_SRC = 1 << 6 #: TCP/UDP destination port. OFPFW_TP_DST = 1 << 7 # See class docstring OFPFW_NW_SRC_SHIFT = 8 OFPFW_NW_SRC_BITS = 6 OFPFW_NW_SRC_MASK = ((1 << OFPFW_NW_SRC_BITS) - 1) << OFPFW_NW_SRC_SHIFT OFPFW_NW_SRC_ALL = 32 << OFPFW_NW_SRC_SHIFT # See class docstring OFPFW_NW_DST_SHIFT = 14 OFPFW_NW_DST_BITS = 6 OFPFW_NW_DST_MASK = ((1 << OFPFW_NW_DST_BITS) - 1) << OFPFW_NW_DST_SHIFT OFPFW_NW_DST_ALL = 32 << OFPFW_NW_DST_SHIFT OFPFW_DL_VLAN_PCP = 1 << 20 OFPFW_NW_TOS = 1 << 21 #: Wildcard all fields. OFPFW_ALL = ((1 << 22) - 1) # Classes class Match(GenericStruct): """Describes a flow entry. Fields to match against flows.""" wildcards = UBInt32(enum_ref=FlowWildCards) in_port = UBInt16() dl_src = HWAddress() dl_dst = HWAddress() dl_vlan = UBInt16() dl_vlan_pcp = UBInt8() #: Align to 64-bits. pad1 = PAD(1) dl_type = UBInt16() nw_tos = UBInt8() nw_proto = UBInt8() #: Align to 64-bits. pad2 = PAD(2) nw_src = UBInt32() nw_dst = UBInt32() tp_src = UBInt16() tp_dst = UBInt16() def __init__(self, wildcards=None, in_port=None, dl_src=None, dl_dst=None, dl_vlan=None, dl_vlan_pcp=None, dl_type=None, nw_tos=None, nw_proto=None, nw_src=None, nw_dst=None, tp_src=None, tp_dst=None): """All the constructor parameters below are optional. Args: wildcards (FlowWildCards): Wildcards fields. in_port (int): Input switch port. dl_src (HWAddress): Ethernet source address. dl_dst (HWAddress): Ethernet destination address. dl_vlan (int): Input VLAN id. dl_vlan_pcp (int): Input VLAN priority. dl_type (int): Ethernet frame type. nw_tos (int): IP ToS (actually DSCP field, 6 bits). nw_proto (int): IP protocol or lower 8 bits of ARP opcode. nw_src (int): IP source address. nw_dst (int): IP destination address. tp_src (int): TCP/UDP source port. tp_dst (int): TCP/UDP destination port. """ super().__init__() self.wildcards = wildcards self.in_port = in_port self.dl_src = dl_src self.dl_dst = dl_dst self.dl_vlan = dl_vlan self.dl_vlan_pcp = dl_vlan_pcp self.dl_type = dl_type self.nw_tos = nw_tos self.nw_proto = nw_proto self.nw_src = nw_src self.nw_dst = nw_dst self.tp_src = tp_src self.tp_dst = tp_dst python-openflow-1.1.0-alpha2/pyof/v0x01/common/header.py000066400000000000000000000041661275711427400227740ustar00rootroot00000000000000"""Defines Header classes and related items.""" # System imports from enum import Enum from random import randint # Local source tree imports from pyof.v0x01.foundation.base import OFP_VERSION, GenericStruct from pyof.v0x01.foundation.basic_types import UBInt8, UBInt16, UBInt32 # Third-party imports __all__ = ('Header', 'Type') # Max xid of a message considering it's size (UBInt32 on v0x01) MAXID = 2147483647 # Enums class Type(Enum): """Enumeration of Message Types.""" # Symetric/Immutable messages OFPT_HELLO = 0 OFPT_ERROR = 1 OFPT_ECHO_REQUEST = 2 OFPT_ECHO_REPLY = 3 OFPT_VENDOR = 4 # Switch configuration messages # Controller/Switch messages OFPT_FEATURES_REQUEST = 5 OFPT_FEATURES_REPLY = 6 OFPT_GET_CONFIG_REQUEST = 7 OFPT_GET_CONFIG_REPLY = 8 OFPT_SET_CONFIG = 9 # Async messages OFPT_PACKET_IN = 10 OFPT_FLOW_REMOVED = 11 OFPT_PORT_STATUS = 12 # Controller command messages # Controller/switch message OFPT_PACKET_OUT = 13 OFPT_FLOW_MOD = 14 OFPT_PORT_MOD = 15 # Statistics messages # Controller/Switch message OFPT_STATS_REQUEST = 16 OFPT_STATS_REPLY = 17 # Barrier messages # Controller/Switch message OFPT_BARRIER_REQUEST = 18 OFPT_BARRIER_REPLY = 19 # Queue Configuration messages # Controller/Switch message OFPT_QUEUE_GET_CONFIG_REQUEST = 20 OFPT_QUEUE_GET_CONFIG_REPLY = 21 # Classes class Header(GenericStruct): """Representation of an OpenFlow message Header.""" version = UBInt8(OFP_VERSION) message_type = UBInt8(enum_ref=Type) length = UBInt16() xid = UBInt32() def __init__(self, message_type=None, length=None, xid=randint(0, MAXID)): """The constructor takes the optional parameters below. Args: message_type (Type): Type of the message. xid (int): ID of the message. Defaults to a random integer. length (int): Length of the message, including the header itself. """ super().__init__() self.message_type = message_type self.length = length self.xid = xid python-openflow-1.1.0-alpha2/pyof/v0x01/common/phy_port.py000066400000000000000000000146331275711427400234100ustar00rootroot00000000000000"""Defines physical port classes and related items.""" # System imports from enum import Enum # Local source tree imports from pyof.v0x01.foundation.base import (OFP_MAX_PORT_NAME_LEN, GenericBitMask, GenericStruct) from pyof.v0x01.foundation.basic_types import (Char, FixedTypeList, HWAddress, UBInt16, UBInt32) # Third-party imports __all__ = ('PhyPort', 'ListOfPhyPorts', 'Port', 'PortConfig', 'PortFeatures', 'PortState') class Port(Enum): """Port numbering. Physical ports are numbered starting from 1. Port number 0 is reserved by the specification and must not be used for a switch physical port. """ #: Maximum number of physical switch ports. OFPP_MAX = 0xff00 #: Send the packet out the input port. This virtual port must be explicitly #: used in order to send back out of the input port. OFPP_IN_PORT = 0xfff8 #: Perform actions in flow table. #: NB: This can only be the destination port for packet-out messages OFPP_TABLE = 0xfff9 #: Process with normal L2/L3 switching. OFPP_NORMAL = 0xfffa #: All physical ports except input port and those disabled by STP OFPP_FLOOD = 0xfffb #: All physical ports except input port OFPP_ALL = 0xfffc #: Send to controller OFPP_CONTROLLER = 0xfffd #: Local openflow "port" OFPP_LOCAL = 0xfffe #: Not associated with a physical port OFPP_NONE = 0xffff class PortConfig(GenericBitMask): """Flags to indicate behavior of the physical port. These flags are used in OFPPhyPort to describe the current configuration. They are used in the OFPPortMod message to configure the port's behavior. """ #: Port is administratively down. OFPC_PORT_DOWN = 1 << 0 #: Disable 802.1D spanning tree on port. OFPPC_NO_STP = 1 << 1 #: Drop all packets except 802.1D spanning tree. OFPPC_NO_RECV = 1 << 2 #: Drop received 802.1D STP packets. OFPPC_NO_RECV_STP = 1 << 3 #: Do not include this port when flooding. OFPPC_FLOOD = 1 << 4 #: Drop packets forwarded to port. OFPPC_NO_FWD = 1 << 5 #: Do not send packet-in msgs for port. OFPPC_NO_PACKET_IN = 1 << 6 class PortFeatures(GenericBitMask): """Physical ports features. The curr, advertised, supported, and peer fields indicate link modes (10M to 10G full and half-duplex), link type (copper/fiber) and link features (autone-gotiation and pause). """ #: 10 Mb half-duplex rate support. OFPPF_10MB_HD = 1 << 0 #: 10 Mb full-duplex rate support. OFPPF_10MB_FD = 1 << 1 #: 100 Mb half-duplex rate support. OFPPF_100MB_HD = 1 << 2 #: 100 Mb full-duplex rate support. OFPPF_100MB_FD = 1 << 3 #: 1 Gb half-duplex rate support. OFPPF_1GB_HD = 1 << 4 #: 1 Gb full-duplex rate support. OFPPF_1GB_FD = 1 << 5 #: 10 Gb full-duplex rate support. OFPPF_10GB_FD = 1 << 6 #: Copper medium. OFPPF_COPPER = 1 << 7 #: Fiber medium. OFPPF_FIBER = 1 << 8 #: Auto-negotiation. OFPPF_AUTONEG = 1 << 9 #: Pause. OFPPF_PAUSE = 1 << 10 #: Asymmetric pause. OFPPF_PAUSE_ASYM = 1 << 11 class PortState(GenericBitMask): """Current state of the physical port. These are not configurable from the controller. The ``OFPPS_STP_*`` bits have no effect on switch operation. The controller must adjust :attr:`PortConfig.OFPPC_NO_RECV`, :attr:`~PortConfig.OFPPC_NO_FWD`, and :attr:`~PortConfig.OFPPC_NO_PACKET_IN` appropriately to fully implement an 802.1D spanning tree. """ #: Not learning or relaying frames. OFPPS_LINK_DOWN = 1 << 0 #: Not learning or relaying frames. OFPPS_STP_LISTEN = 0 << 8 #: Learning but not relaying frames. OFPPS_STP_LEARN = 1 << 8 #: Learning and relaying frames. OFPPS_STP_FORWARD = 2 << 8 #: Not part of spanning tree. OFPPS_STP_BLOCK = 3 << 8 # Classes class PhyPort(GenericStruct): """Description of a physical port. The port_no field is a value the datapath associates with a physical port. The hw_addr field typically is the MAC address for the port; :data:`.OFP_ETH_ALEN` is 6. The name field is a null-terminated string containing a human-readable name for the interface. The value of :data:`.OFP_MAX_PORT_NAME_LEN` is 16. :attr:`curr`, :attr:`advertised`, :attr:`supported` and :attr:`peer` are bitmaps of :class:`PortFeatures` enum values that describe features. If unsupported or unavailable, set all bits to zero. """ port_no = UBInt16() hw_addr = HWAddress() name = Char(length=OFP_MAX_PORT_NAME_LEN) config = UBInt32(enum_ref=PortConfig) state = UBInt32(enum_ref=PortState) curr = UBInt32(enum_ref=PortFeatures) advertised = UBInt32(enum_ref=PortFeatures) supported = UBInt32(enum_ref=PortFeatures) peer = UBInt32(enum_ref=PortFeatures) def __init__(self, port_no=None, hw_addr=None, name=None, config=None, state=None, curr=None, advertised=None, supported=None, peer=None): """The constructor takes the optional parameters below. Args: port_no (int): Port number. hw_addr (HWAddress): Hardware address. name(str): Null-terminated name. config (PortConfig): Bitmap of OFPPC* flags. state (PortState): Bitmap of OFPPS* flags. curr (PortFeatures): Current features. advertised (PortFeatures): Features being advertised by the port. supported (PortFeatures): Features supported by the port. peer (PortFeatures): Features advertised by peer. """ super().__init__() self.port_no = port_no self.hw_addr = hw_addr self.name = name self.config = config self.state = state self.curr = curr self.advertised = advertised self.supported = supported self.peer = peer class ListOfPhyPorts(FixedTypeList): """List of PhyPorts. Represented by instances of PhyPort and used on :class:`.FeaturesReply`/:class:`.SwitchFeatures` objects. """ def __init__(self, items=None): """The constructor takes the optional parameter below. Args: items (:class:`list`, :class:`PhyPort`): One :class:`PhyPort` instance or list. """ super().__init__(pyof_class=PhyPort, items=items) python-openflow-1.1.0-alpha2/pyof/v0x01/common/queue.py000066400000000000000000000066621275711427400226730ustar00rootroot00000000000000"""Defines OpenFlow queues structures and related items.""" # System imports from enum import Enum # Local source tree imports from pyof.v0x01.foundation.base import GenericStruct from pyof.v0x01.foundation.basic_types import (PAD, FixedTypeList, UBInt16, UBInt32) # Third-party imports __all__ = ('QueuePropHeader', 'PacketQueue', 'QueuePropMinRate', 'QueueProperties', 'ListOfProperties', 'ListOfQueues') # Enums class QueueProperties(Enum): """Describe queue properties.""" #: No property defined for queue (default) OFPQT_NONE = 0 #: Minimum datarate guaranteed OFPQT_MIN_RATE = 1 # Classes class ListOfProperties(FixedTypeList): """List of properties. Represented by instances of :class:`QueuePropHeader` and used on :class:`PacketQueue` objects. """ def __init__(self, items=None): """The contructor takes the paremeters below. Args: items (:class:`list` of/or :class:`QueuePropHeader`): :class:`QueuePropHeader` instance or list of instances. """ super().__init__(pyof_class=QueuePropHeader, items=items) class QueuePropHeader(GenericStruct): """Describe the header of each queue property.""" property = UBInt16(enum_ref=QueueProperties) len = UBInt16() #: 64-bit alignment pad = PAD(4) def __init__(self, prop=None, length=None): """The contructor takes the paremeters below. Args: property (QueueProperties): The queue property. len (int): Length of property, including this header. """ super().__init__() self.property = prop self.len = length class PacketQueue(GenericStruct): """Describe a queue.""" queue_id = UBInt32() length = UBInt16() #: 64-bit alignment. pad = PAD(2) properties = ListOfProperties() def __init__(self, queue_id=None, length=None, properties=None): """The contructor takes the paremeters below. Args: queue_id (int): ID of the specific queue. length (int): Length in bytes of this queue desc. properties(ListOfProperties): Queue's list of properties. Default is an empty list. """ super().__init__() self.queue_id = queue_id self.length = length self.properties = [] if properties is None else properties class QueuePropMinRate(GenericStruct): """Define the minimum-rate type queue.""" prop_header = QueuePropHeader(prop=QueueProperties.OFPQT_MIN_RATE, length=16) rate = UBInt16() #: 64-bit alignmet. pad = PAD(6) def __init__(self, rate=None): """The contructor takes the paremeters below. Args: rate (int): In 1/10 of a percent (1000 -> 100%); >1000 -> disabled. """ super().__init__() self.rate = rate class ListOfQueues(FixedTypeList): """List of queues. Represented by instances of :class:`PacketQueue` and used on :class:`QueueGetConfigReply` objects. """ def __init__(self, items=None): """The contructor takes the paremeters below. Args: items (:class:`list` of/or :class:`PacketQueue`): :class:`PacketQueue` instance or list of instances. """ super().__init__(pyof_class=PacketQueue, items=items) python-openflow-1.1.0-alpha2/pyof/v0x01/common/utils.py000066400000000000000000000107301275711427400226760ustar00rootroot00000000000000"""Helper python-openflow functions.""" # System imports # Third-party imports # Local source tree imports # Importing asynchronous messages from pyof.v0x01.asynchronous.error_msg import ErrorMsg from pyof.v0x01.asynchronous.flow_removed import FlowRemoved from pyof.v0x01.asynchronous.packet_in import PacketIn from pyof.v0x01.asynchronous.port_status import PortStatus # Importing controller2switch messages from pyof.v0x01.common.header import Type from pyof.v0x01.controller2switch.barrier_reply import BarrierReply from pyof.v0x01.controller2switch.barrier_request import BarrierRequest from pyof.v0x01.controller2switch.features_reply import FeaturesReply from pyof.v0x01.controller2switch.features_request import FeaturesRequest from pyof.v0x01.controller2switch.flow_mod import FlowMod from pyof.v0x01.controller2switch.get_config_reply import GetConfigReply from pyof.v0x01.controller2switch.get_config_request import GetConfigRequest from pyof.v0x01.controller2switch.packet_out import PacketOut from pyof.v0x01.controller2switch.port_mod import PortMod from pyof.v0x01.controller2switch.queue_get_config_reply import \ QueueGetConfigReply from pyof.v0x01.controller2switch.queue_get_config_request import \ QueueGetConfigRequest from pyof.v0x01.controller2switch.set_config import SetConfig from pyof.v0x01.controller2switch.stats_reply import StatsReply from pyof.v0x01.controller2switch.stats_request import StatsRequest # Importing symmetric messages from pyof.v0x01.symmetric.echo_reply import EchoReply from pyof.v0x01.symmetric.echo_request import EchoRequest from pyof.v0x01.symmetric.hello import Hello from pyof.v0x01.symmetric.vendor_header import VendorHeader __all__ = ('new_message_from_header', 'new_message_from_message_type') def new_message_from_message_type(message_type): """Given an OpenFlow Message Type, return an empty message of that type. Args: messageType (:class:~.common.header.Type): Python-openflow message. Returns: Empty OpenFlow message of the requested message type. Raises: KytosUndefinedMessageType: Unkown Message_Type. """ message_type = str(message_type) available_classes = { str(Type.OFPT_HELLO): Hello, str(Type.OFPT_ERROR): ErrorMsg, str(Type.OFPT_ECHO_REQUEST): EchoRequest, str(Type.OFPT_ECHO_REPLY): EchoReply, str(Type.OFPT_VENDOR): VendorHeader, str(Type.OFPT_FEATURES_REQUEST): FeaturesRequest, str(Type.OFPT_FEATURES_REPLY): FeaturesReply, str(Type.OFPT_GET_CONFIG_REQUEST): GetConfigRequest, str(Type.OFPT_GET_CONFIG_REPLY): GetConfigReply, str(Type.OFPT_SET_CONFIG): SetConfig, str(Type.OFPT_PACKET_IN): PacketIn, str(Type.OFPT_FLOW_REMOVED): FlowRemoved, str(Type.OFPT_PORT_STATUS): PortStatus, str(Type.OFPT_PACKET_OUT): PacketOut, str(Type.OFPT_FLOW_MOD): FlowMod, str(Type.OFPT_PORT_MOD): PortMod, str(Type.OFPT_STATS_REQUEST): StatsRequest, str(Type.OFPT_STATS_REPLY): StatsReply, str(Type.OFPT_BARRIER_REQUEST): BarrierRequest, str(Type.OFPT_BARRIER_REPLY): BarrierReply, str(Type.OFPT_QUEUE_GET_CONFIG_REQUEST): QueueGetConfigRequest, str(Type.OFPT_QUEUE_GET_CONFIG_REPLY): QueueGetConfigReply } if message_type not in available_classes: raise ValueError message_class = available_classes.get(message_type) message_instance = message_class() return message_instance def new_message_from_header(header): """Given an OF Header, return an empty message of header's message_type. Args: header (Header): Unpacked OpenFlow Header. Returns: Empty OpenFlow message of the same type of message_type attribute from the given header. The header attribute of the message will be populated. Raises: KytosUndefinedMessageType: Unkown Message_Type. """ message_type = header.message_type if not isinstance(message_type, Type): try: if isinstance(message_type, str): # False positive https://github.com/PyCQA/pylint/issues/992 # pylint: disable=E1136 message_type = Type[message_type] elif isinstance(message_type, int): message_type = Type(message_type) except ValueError: raise ValueError message = new_message_from_message_type(message_type) message.header.xid = header.xid message.header.length = header.length return message python-openflow-1.1.0-alpha2/pyof/v0x01/controller2switch/000077500000000000000000000000001275711427400233625ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/pyof/v0x01/controller2switch/__init__.py000066400000000000000000000000761275711427400254760ustar00rootroot00000000000000"""Controller to Switch and Switch to Controller Messages.""" python-openflow-1.1.0-alpha2/pyof/v0x01/controller2switch/barrier_reply.py000066400000000000000000000011771275711427400266030ustar00rootroot00000000000000"""Defines Barrier Reply message.""" # System imports # Third-party imports from pyof.v0x01.common.header import Header, Type from pyof.v0x01.foundation.base import GenericMessage __all__ = ('BarrierReply',) # Classes class BarrierReply(GenericMessage): """OpenFlow Barrier Reply Message. This message does not contain a body beyond the OpenFlow Header. """ header = Header(message_type=Type.OFPT_BARRIER_REPLY) def __init__(self, xid=None): """The constructor just assings parameters to object attributes. Args: xid (int): Header's xid. """ super().__init__(xid) python-openflow-1.1.0-alpha2/pyof/v0x01/controller2switch/barrier_request.py000066400000000000000000000012511275711427400271310ustar00rootroot00000000000000"""Defines Barrier Request message.""" # System imports # Third-party imports from pyof.v0x01.common.header import Header, Type from pyof.v0x01.foundation.base import GenericMessage __all__ = ('BarrierRequest',) # Classes class BarrierRequest(GenericMessage): """OpenFlow Barrier Request Message. This message does not contain a body in addition to the OpenFlow Header. """ header = Header(message_type=Type.OFPT_BARRIER_REQUEST) def __init__(self, xid=None): """The constructor just assings parameters to object attributes. Args: xid (int): xid to be used on the message header. """ super().__init__(xid) python-openflow-1.1.0-alpha2/pyof/v0x01/controller2switch/common.py000066400000000000000000000354411275711427400252330ustar00rootroot00000000000000"""Defines common structures and enums for controller2switch.""" # System imports from enum import Enum # Local source tree imports from pyof.v0x01.common.action import ActionHeader from pyof.v0x01.common.flow_match import FlowWildCards, Match from pyof.v0x01.common.header import Header from pyof.v0x01.foundation.base import (DESC_STR_LEN, OFP_MAX_TABLE_NAME_LEN, SERIAL_NUM_LEN, GenericMessage, GenericStruct) from pyof.v0x01.foundation.basic_types import (PAD, Char, FixedTypeList, UBInt8, UBInt16, UBInt32, UBInt64) # Third-party imports __all__ = ('ConfigFlags', 'StatsTypes', 'AggregateStatsReply', 'AggregateStatsRequest', 'DescStats', 'FlowStatsRequest', 'PortStats', 'PortStatsRequest', 'QueueStats', 'QueueStatsRequest', 'TableStats') # Enums class ConfigFlags(Enum): """Configuration Flags. Handling of IP Fragments.""" #: No special handling for fragments OFPC_FRAG_NORMAL = 0 #: Drop fragments OFPC_FRAG_DROP = 1 #: Reassemble (only if OFPC_IP_REASM set) OFPC_FRAG_REASM = 2 OFPC_FRAG_MASK = 3 class StatsTypes(Enum): """Type field to be used both in both request and reply. It specifies the kind of information being passed and determines how the body field is interpreted. """ #: Description of this OpenFlow switch. The request body is empty. OFPST_DESC = 0 #: Individual flow statistics. The request body is struct #: ofp_flow_stats_request. OFPST_FLOW = 1 #: Aggregate flow statistics. The request body is struct #: ofp_aggregate_stats_request. OFPST_AGGREGATE = 2 #: Flow table statistics. The request body is empty. OFPST_TABLE = 3 #: Physical port statistics. The request body is empty. OFPST_PORT = 4 #: Queue statistics for a port. The request body defines the port OFPST_QUEUE = 5 #: Vendor extension. The request and reply bodies begin with a 32-bit #: vendor ID OFPST_VENDOR = 0xffff # Classes class SwitchConfig(GenericMessage): """Used as base class for SET_CONFIG and GET_CONFIG_REPLY messages.""" header = Header() flags = UBInt16(enum_ref=ConfigFlags) miss_send_len = UBInt16() def __init__(self, xid=None, flags=None, miss_send_len=None): """The constructor just assings parameters to object attributes. Args: xid (int): xid to be used on the message header. flags (ConfigFlags): OFPC_* flags. miss_send_len (int): UBInt16 max bytes of new flow that the datapath should send to the controller. """ super().__init__(xid) self.flags = flags self.miss_send_len = miss_send_len class ListOfActions(FixedTypeList): """List of actions. Represented by instances of ActionHeader and used on ActionHeader objects. """ def __init__(self, items=None): """The constructor just assings parameters to object attributes. Args: items (ActionHeader): Instance or a list of instances. """ super().__init__(pyof_class=ActionHeader, items=items) class AggregateStatsReply(GenericStruct): """Body of reply to OFPST_AGGREGATE request.""" packet_count = UBInt64() byte_count = UBInt64() flow_count = UBInt32() #: Align to 64 bits pad = PAD(4) def __init__(self, packet_count=None, byte_count=None, flow_count=None): """The constructor just assings parameters to object attributes. Args: packet_count (int): Number of packets in flows byte_count (int): Number of bytes in flows flow_count (int): Number of flows """ super().__init__() self.packet_count = packet_count self.byte_count = byte_count self.flow_count = flow_count class AggregateStatsRequest(GenericStruct): """Body for ofp_stats_request of type OFPST_AGGREGATE.""" match = Match() table_id = UBInt8() #: Align to 32 bits pad = PAD(1) out_port = UBInt16() def __init__(self, match=None, table_id=None, out_port=None): """The constructor just assings parameters to object attributes. Args: match (Match): Fields to match. table_id (int): ID of table to read (from pyof_table_stats) 0xff for all tables or 0xfe for emergency. out_port (int): Require matching entries to include this as an output port. A value of OFPP_NONE indicates no restriction. """ super().__init__() self.match = match self.table_id = table_id self.out_port = out_port class DescStats(GenericStruct): """Information available from the OFPST_DESC stats request. Information about the switch manufacturer, hardware revision, software revision, serial number and a description field. """ mfr_desc = Char(length=DESC_STR_LEN) hw_desc = Char(length=DESC_STR_LEN) sw_desc = Char(length=DESC_STR_LEN) serial_num = Char(length=SERIAL_NUM_LEN) dp_desc = Char(length=DESC_STR_LEN) def __init__(self, mfr_desc=None, hw_desc=None, sw_desc=None, serial_num=None, dp_desc=None): """The constructor just assings parameters to object attributes. Args: mfr_desc (str): Manufacturer description hw_desc (str): Hardware description sw_desc (str): Software description serial_num (str): Serial number dp_desc (str): Human readable description of datapath """ super().__init__() self.mfr_desc = mfr_desc self.hw_desc = hw_desc self.sw_desc = sw_desc self.serial_num = serial_num self.dp_desc = dp_desc class FlowStats(GenericStruct): """Body of reply to OFPST_FLOW request.""" length = UBInt16() table_id = UBInt8() #: Align to 32 bits. pad = PAD(1) match = Match() duration_sec = UBInt32() duration_nsec = UBInt32() priority = UBInt16() idle_timeout = UBInt16() hard_timeout = UBInt16() #: Align to 64-bits pad2 = PAD(6) cookie = UBInt64() packet_count = UBInt64() byte_count = UBInt64() actions = ListOfActions() def __init__(self, length=None, table_id=None, match=None, duration_sec=None, duration_nsec=None, priority=None, idle_timeout=None, hard_timeout=None, cookie=None, packet_count=None, byte_count=None, actions=None): """The constructor just assings parameters to object attributes. Args: length (int): Length of this entry. table_id (int): ID of table flow came from. match (Match): Description of fields. duration_sec (int): Time flow has been alive in seconds. duration_nsec (int): Time flow has been alive in nanoseconds in addition to duration_sec. priority (int): Priority of the entry. Only meaningful when this is not an exact-match entry. idle_timeout (int): Number of seconds idle before expiration. hard_timeout (int): Number of seconds before expiration. cookie (int): Opaque controller-issued identifier. packet_count (int): Number of packets in flow. byte_count (int): Number of bytes in flow. actions (ListOfActions): Actions. """ super().__init__() self.length = length self.table_id = table_id self.match = match self.duration_sec = duration_sec self.duration_nsec = duration_nsec self.prioriry = priority self.idle_timeout = idle_timeout self.hard_timeout = hard_timeout self.cookie = cookie self.packet_count = packet_count self.byte_count = byte_count self.actions = [] if actions is None else actions class FlowStatsRequest(GenericStruct): """Body for ofp_stats_request of type OFPST_FLOW.""" match = Match() table_id = UBInt8() #: Align to 32 bits. pad = PAD(1) out_port = UBInt16() def __init__(self, match=None, table_id=None, out_port=None): """The constructor just assings parameters to object attributes. Args: match (Match): Fields to match. table_id (int): ID of table to read (from pyof_table_stats) 0xff for all tables or 0xfe for emergency. out_port (:class:`int`, :class:`.Port`): Require matching entries to include this as an output port. A value of :attr:`.Port.OFPP_NONE` indicates no restriction. """ super().__init__() self.match = match self.table_id = table_id self.out_port = out_port class PortStats(GenericStruct): """Body of reply to OFPST_PORT request. If a counter is unsupported, set the field to all ones. """ port_no = UBInt16() #: Align to 64-bits. pad = PAD(6) rx_packets = UBInt64() tx_packets = UBInt64() rx_bytes = UBInt64() tx_bytes = UBInt64() rx_dropped = UBInt64() tx_dropped = UBInt64() rx_errors = UBInt64() tx_errors = UBInt64() rx_frame_err = UBInt64() rx_over_err = UBInt64() rx_crc_err = UBInt64() collisions = UBInt64() def __init__(self, port_no=None, rx_packets=None, tx_packets=None, rx_bytes=None, tx_bytes=None, rx_dropped=None, tx_dropped=None, rx_errors=None, tx_errors=None, rx_frame_err=None, rx_over_err=None, rx_crc_err=None, collisions=None): """The constructor assigns parameters to object attributes. Args: port_no (:class:`int`, :class:`.Port`): Port number. rx_packets (int): Number of received packets. tx_packets (int): Number of transmitted packets. rx_bytes (int): Number of received bytes. tx_bytes (int): Number of transmitted bytes. rx_dropped (int): Number of packets dropped by RX. tx_dropped (int): Number of packets dropped by TX. rx_errors (int): Number of receive errors. This is a super-set of more specific receive errors and should be greater than or equal to the sum of all rx_*_err values. tx_errors (int): Number of transmit errors. This is a super-set of more specific transmit errors and should be greater than or equal to the sum of all tx_*_err values (none currently defined). rx_frame_err (int): Number of frame alignment errors. rx_over_err (int): Number of packets with RX overrun. rx_crc_err (int): Number of CRC errors. collisions (int): Number of collisions. """ super().__init__() self.port_no = port_no self.rx_packets = rx_packets self.tx_packets = tx_packets self.rx_bytes = rx_bytes self.tx_bytes = tx_bytes self.rx_dropped = rx_dropped self.tx_dropped = tx_dropped self.rx_errors = rx_errors self.tx_errors = tx_errors self.rx_frame_err = rx_frame_err self.rx_over_err = rx_over_err self.rx_crc_err = rx_crc_err self.collisions = collisions class PortStatsRequest(GenericStruct): """Body for ofp_stats_request of type OFPST_PORT.""" port_no = UBInt16() #: Align to 64-bits. pad = PAD(6) def __init__(self, port_no=None): """The constructor just assings parameters to object attributes. Args: port_no (:class:`int`, :class:`.Port`): OFPST_PORT message must request statistics either for a single port (specified in ``port_no``) or for all ports (if port_no == :attr:`.Port.OFPP_NONE`). """ super().__init__() self.port_no = port_no class QueueStats(GenericStruct): """Implements the reply body of a port_no.""" port_no = UBInt16() #: Align to 32-bits. pad = PAD(2) queue_id = UBInt32() tx_bytes = UBInt64() tx_packets = UBInt64() tx_errors = UBInt64() def __init__(self, port_no=None, queue_id=None, tx_bytes=None, tx_packets=None, tx_errors=None): """The constructor just assings parameters to object attributes. Args: port_no (:class:`int`, :class:`.Port`): Port Number. queue_id (int): Queue ID. tx_bytes (int): Number of transmitted bytes. tx_packets (int): Number of transmitted packets. tx_errors (int): Number of packets dropped due to overrun. """ super().__init__() self.port_no = port_no self.queue_id = queue_id self.tx_bytes = tx_bytes self.tx_packets = tx_packets self.tx_errors = tx_errors class QueueStatsRequest(GenericStruct): """Implements the request body of a ``port_no``.""" port_no = UBInt16() #: Align to 32-bits pad = PAD(2) queue_id = UBInt32() def __init__(self, port_no=None, queue_id=None): """The constructor just assings parameters to object attributes. Args: port_no (:class:`int`, :class:`.Port`): All ports if :attr:`.Port.OFPP_ALL`. queue_id (int): All queues if OFPQ_ALL. """ super().__init__() self.port_no = port_no self.queue_id = queue_id class TableStats(GenericStruct): """Body of reply to OFPST_TABLE request.""" table_id = UBInt8() #: Align to 32-bits. pad = PAD(3) name = Char(length=OFP_MAX_TABLE_NAME_LEN) wildcards = UBInt32(enum_ref=FlowWildCards) max_entries = UBInt32() active_count = UBInt32() count_lookup = UBInt64() count_matched = UBInt64() def __init__(self, table_id=None, name=None, wildcards=None, max_entries=None, active_count=None, count_lookup=None, count_matched=None): """The constructor just assings parameters to object attributes. Args: table_id (int): Identifier of table. Lower numbered tables are consulted first. name (str): Table name. wildcards (FlowWildCards): Bitmap of OFPFW_* wildcards that are supported by the table. max_entries (int): Max number of entries supported. active_count (int): Number of active entries. count_lookup (int): Number of packets looked up in table. count_matched (int): Number of packets that hit table. """ super().__init__() self.table_id = table_id self.name = name self.wildcards = wildcards self.max_entries = max_entries self.active_count = active_count self.count_lookup = count_lookup self.count_matched = count_matched python-openflow-1.1.0-alpha2/pyof/v0x01/controller2switch/features_reply.py000066400000000000000000000073721275711427400267760ustar00rootroot00000000000000"""Defines Features Reply classes and related items.""" # System imports # Third-party imports # Local source tree imports from pyof.v0x01.common.action import ActionType from pyof.v0x01.common.header import Header, Type from pyof.v0x01.common.phy_port import ListOfPhyPorts from pyof.v0x01.foundation.base import GenericBitMask, GenericMessage from pyof.v0x01.foundation.basic_types import PAD, UBInt8, UBInt32, UBInt64 __all__ = ('FeaturesReply', 'Capabilities', 'SwitchFeatures') class Capabilities(GenericBitMask): """Capabilities supported by the datapath.""" #: Flow statistics OFPC_FLOW_STATS = 1 << 0 #: Table statistics OFPC_TABLE_STATS = 1 << 1 #: Port statistics OFPC_PORT_STATS = 1 << 2 #: 802.1d spanning tree OFPC_STP = 1 << 3 #: Reserved, must be zero OFPC_RESERVED = 1 << 4 #: Can reassembe IP fragments OFPC_IP_REASM = 1 << 5 #: Queue statistics OFPC_QUEUE_STATS = 1 << 6 #: Match IP addresses in ARP pkts OFPC_ARP_MATCH_IP = 1 << 7 # Classes class SwitchFeatures(GenericMessage): """Message sent by the switch device to the controller. This message is the response for a features_request message, sent by the controller to the switch device. The 'OFPT_FEATURES_REPLY' message inherits from this class, despite the strange name. """ header = Header(message_type=Type.OFPT_FEATURES_REPLY) datapath_id = UBInt64() n_buffers = UBInt32() n_tables = UBInt8() #: Align to 64-bits. pad = PAD(3) # Features capabilities = UBInt32(enum_ref=Capabilities) actions = UBInt32(enum_ref=ActionType) ports = ListOfPhyPorts() def __init__(self, xid=None, datapath_id=None, n_buffers=None, n_tables=None, capabilities=None, actions=None, ports=None): """The constructor just assings parameters to object attributes. Args: xid (int): xid to be used on the message header. datapath_id (int): UBInt64 datapath unique ID. The lower 48-bits are for MAC address, while the upper 16-bits are implementer-defined. n_buffers (int): UBInt32 max packets buffered at once. n_tables (int): UBInt8 number of tables supported by datapath. capabilities (int): UBInt32 bitmap of supported capabilities. actions (int): UBInt32 Bitmap of supported "action_type"s. ports (int): Port definitions. """ super().__init__(xid) self.datapath_id = datapath_id self.n_buffers = n_buffers self.n_tables = n_tables self.capabilities = capabilities self.actions = actions self.ports = [] if ports is None else ports class FeaturesReply(SwitchFeatures): """'OFPT_FEATURES_REPLY' message.""" def __init__(self, xid=None, datapath_id=None, n_buffers=None, n_tables=None, capabilities=None, actions=None, ports=None): """The constructor just assings parameters to object attributes. Args: xid (int): xid to be used on the message header. datapath_id (int): UBInt64 datapath unique ID. The lower 48-bits are for MAC address, while the upper 16-bits are implementer-defined. n_buffers (int): UBInt32 max packets buffered at once. n_tables (int): UBInt8 number of tables supported by datapath. capabilities (int): UBInt32 bitmap of supported capabilities. actions (int): UBInt32 Bitmap of supported "action_type"s. ports (int): Port definitions. """ self.__ordered__ = super().__ordered__ # pylint: disable=no-member super().__init__(xid, datapath_id, n_buffers, n_tables, capabilities, actions, ports) python-openflow-1.1.0-alpha2/pyof/v0x01/controller2switch/features_request.py000066400000000000000000000012151275711427400273210ustar00rootroot00000000000000"""Defines Features Request classes and related items.""" from pyof.v0x01.common.header import Header, Type from pyof.v0x01.foundation.base import GenericMessage __all__ = ('FeaturesRequest',) # Classes class FeaturesRequest(GenericMessage): """Features request message. This message does not contain a body in addition to the OpenFlow Header. """ header = Header( message_type=Type.OFPT_FEATURES_REQUEST) def __init__(self, xid=None): """The constructor takes the optional parameter below. Args: xid (int): xid to be used on the message header. """ super().__init__(xid) python-openflow-1.1.0-alpha2/pyof/v0x01/controller2switch/flow_mod.py000066400000000000000000000063611275711427400255500ustar00rootroot00000000000000"""Modifications to the flow table from the controller.""" # System imports from enum import Enum # Local source tree imports from pyof.v0x01.common.flow_match import Match from pyof.v0x01.common.header import Header, Type from pyof.v0x01.common.phy_port import Port from pyof.v0x01.controller2switch.common import ListOfActions from pyof.v0x01.foundation.base import GenericBitMask, GenericMessage from pyof.v0x01.foundation.basic_types import UBInt16, UBInt32, UBInt64 # Third-party imports __all__ = ('FlowMod', 'FlowModCommand', 'FlowModFlags') # Enums class FlowModCommand(Enum): """List the possible commands for a flow.""" #: New flow OFPFC_ADD = 0 #: Modify all flows OFPFC_MODIFY = 1 #: Modify entry strictly matching wildcards OFPFC_MODIFY_STRICT = 2 #: Delete all matching flows OFPFC_DELETE = 3 #: Strictly match wildcards and priority OFPFC_DELETE_STRICT = 4 class FlowModFlags(GenericBitMask): """Types to be used in Flags field.""" #: Send flow removed message when flow expires or is deleted OFPFF_SEND_FLOW_REM = 1 << 0 #: Check for overlapping entries first OFPFF_CHECK_OVERLAP = 1 << 1 #: Remark this is for emergency OFPFF_EMERG = 1 << 2 # Classes class FlowMod(GenericMessage): """Modifies the flow table from the controller.""" header = Header(message_type=Type.OFPT_FLOW_MOD) match = Match() cookie = UBInt64() command = UBInt16(enum_ref=FlowModCommand) idle_timeout = UBInt16() hard_timeout = UBInt16() priority = UBInt16() buffer_id = UBInt32() out_port = UBInt16(enum_ref=Port) flags = UBInt16(enum_ref=FlowModFlags) actions = ListOfActions() def __init__(self, xid=None, match=None, cookie=None, command=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, flags=None, actions=None): """The constructor just assings parameters to object attributes. Args: xid (int): xid to be used on the message header. match (Match): Fields to match. cookie (int): Opaque controller-issued identifier. command (FlowModCommand): One of OFPFC_*. idle_timeout (int): Idle time before discarding (seconds). hard_timeout (int): Max time before discarding (seconds). priority (int): Priority level of flow entry. buffer_idle (int): Buffered packet to apply to (or -1). Not meaningful for OFPFC_DELETE*. out_port (Port): For OFPFC_DELETE* commands, require matching entries to include this as an output port. A value of OFPP_NONE indicates no restriction. flags (FlowModFlags): One of OFPFF_*. actions (ListOfActions): The action length is inferred from the length field in the header. """ super().__init__(xid) self.match = match self.cookie = cookie self.command = command self.idle_timeout = idle_timeout self.hard_timeout = hard_timeout self.priority = priority self.buffer_id = buffer_id self.out_port = out_port self.flags = flags self.actions = [] if actions is None else actions python-openflow-1.1.0-alpha2/pyof/v0x01/controller2switch/get_config_reply.py000066400000000000000000000015551275711427400272610ustar00rootroot00000000000000"""Defines Get Config Reply message.""" # System imports # Third-party imports from pyof.v0x01.common.header import Type from pyof.v0x01.controller2switch.common import SwitchConfig __all__ = ('GetConfigReply',) class GetConfigReply(SwitchConfig): """Get Config Reply message.""" def __init__(self, xid=None, flags=None, miss_send_len=None): """The constructor just assings parameters to object attributes. Args: xid (int): xid to be used on the message header. flags (ConfigFlags): OFPC_* flags. miss_send_len (int): UBInt16 max bytes of new flow that the datapath should send to the controller. """ self.__ordered__ = super().__ordered__ # pylint: disable=no-member super().__init__(xid, flags, miss_send_len) self.header.message_type = Type.OFPT_SET_CONFIG python-openflow-1.1.0-alpha2/pyof/v0x01/controller2switch/get_config_request.py000066400000000000000000000012141275711427400276060ustar00rootroot00000000000000"""Defines Get Config Request classes and related items.""" from pyof.v0x01.common.header import Header, Type from pyof.v0x01.foundation.base import GenericMessage __all__ = ('GetConfigRequest',) # Classe class GetConfigRequest(GenericMessage): """Get Config Request message.""" header = Header(message_type=Type.OFPT_GET_CONFIG_REQUEST) def __init__(self, xid=None): """The constructor just assings parameters to object attributes. This message does not contain a body beyond the OpenFlow Header. Args: xid (int): xid to be used on the message header. """ super().__init__(xid) python-openflow-1.1.0-alpha2/pyof/v0x01/controller2switch/packet_out.py000066400000000000000000000076171275711427400261050ustar00rootroot00000000000000"""For the controller to send a packet out through the datapath.""" from copy import deepcopy from pyof.v0x01.common.header import Header, Type from pyof.v0x01.common.phy_port import Port from pyof.v0x01.controller2switch.common import ListOfActions from pyof.v0x01.foundation.base import GenericMessage from pyof.v0x01.foundation.basic_types import BinaryData, UBInt16, UBInt32 from pyof.v0x01.foundation.exceptions import ValidationError __all__ = ('PacketOut',) # Classes #: in_port valid virtual port values, for validation _VIRT_IN_PORTS = (Port.OFPP_LOCAL, Port.OFPP_CONTROLLER, Port.OFPP_NONE) class PacketOut(GenericMessage): """Send packet (controller -> datapath).""" header = Header(message_type=Type.OFPT_PACKET_OUT) buffer_id = UBInt32() in_port = UBInt16(enum_ref=Port) actions_len = UBInt16() actions = ListOfActions() data = BinaryData() def __init__(self, xid=None, buffer_id=None, in_port=None, actions_len=None, actions=None, data=b''): """The constructor just assings parameters to object attributes. Args: xid (int): xid of the message header. buffer_id (int): ID assigned by datapath (-1 if none). in_port (:class:`int`, :class:`.Port`): Packet's input port (:attr:`.Port.OFPP_NONE` if none). Virtual ports OFPP_IN_PORT, OFPP_TABLE, OFPP_NORMAL, OFPP_FLOOD, and OFPP_ALL cannot be used as input port. actions_len (int): Size of action array in bytes. actions (ListOfActions): Actions (class ActionHeader). data (bytes): Packet data. The length is inferred from the length field in the header. (Only meaningful if buffer_id == -1). """ super().__init__(xid) self.buffer_id = buffer_id self.in_port = in_port self.actions_len = actions_len self.actions = [] if actions is None else actions self.data = data def validate(self): """Validate the entire message.""" if not super().is_valid(): raise ValidationError() self._validate_in_port() def is_valid(self): """Answer if this message is valid.""" try: self.validate() return True except ValidationError: return False def unpack(self, buff, offset=0): """Unpack a binary message into this object's attributes. Unpack the binary value *buff* and update this object attributes based on the results. It is an inplace method and it receives the binary data of the message **without the header**. This class' unpack method is like the :meth:`.GenericMessage.unpack` one, except for the ``actions`` attribute which has a length determined by the ``actions_len`` attribute. Args: buff (bytes): Binary data package to be unpacked, without the header. offset (int): Where to begin unpacking. """ begin = offset for attribute_name, class_attribute in self.get_class_attributes(): if type(class_attribute).__name__ != "Header": attribute = deepcopy(class_attribute) if attribute_name == 'actions': length = self.actions_len.value attribute.unpack(buff[begin:begin+length]) else: attribute.unpack(buff, begin) setattr(self, attribute_name, attribute) begin += attribute.get_size() def _validate_in_port(self): port = self.in_port valid = True if isinstance(port, int) and (port < 1 or port >= Port.OFPP_MAX.value): valid = False elif isinstance(port, Port) and port not in _VIRT_IN_PORTS: valid = False if not valid: raise ValidationError('{} is not a valid input port.'.format(port)) python-openflow-1.1.0-alpha2/pyof/v0x01/controller2switch/port_mod.py000066400000000000000000000032251275711427400255610ustar00rootroot00000000000000"""Modifications to the port from the controller.""" # System imports # Third-party imports # Local source tree imports from pyof.v0x01.common.header import Header, Type from pyof.v0x01.common.phy_port import PortConfig, PortFeatures from pyof.v0x01.foundation.base import GenericMessage from pyof.v0x01.foundation.basic_types import PAD, HWAddress, UBInt16, UBInt32 __all__ = ('PortMod',) # Classes class PortMod(GenericMessage): """Implement messages to modify the physical port behavior.""" header = Header(message_type=Type.OFPT_PORT_MOD) port_no = UBInt16() hw_addr = HWAddress() config = UBInt32(enum_ref=PortConfig) mask = UBInt32(enum_ref=PortConfig) advertise = UBInt32(enum_ref=PortFeatures) #: Pad to 64-bits. pad = PAD(4) def __init__(self, xid=None, port_no=None, hw_addr=None, config=None, mask=None, advertise=None): """The constructor just assings parameters to object attributes. Args: xid (int): OpenFlow xid to the header. port_no (int): Physical port number. hw_addr (HWAddress): The hardware address is not configurable. This is used to sanity-check the request, so it must be the same as returned in an ofp_phy_port struct. config (PortConfig): Bitmap of OFPPC_* flags mask (PortConfig): Bitmap of OFPPC_* flags to be changed advertise (PortFeatures): Bitmap of "ofp_port_features"s """ super().__init__(xid) self.port_no = port_no self.hw_addr = hw_addr self.config = config self.mask = mask self.advertise = advertise python-openflow-1.1.0-alpha2/pyof/v0x01/controller2switch/queue_get_config_reply.py000066400000000000000000000021241275711427400304560ustar00rootroot00000000000000"""Switch replies to controller.""" # System imports # Third-party imports # Local source tree imports from pyof.v0x01.common.header import Header, Type from pyof.v0x01.common.phy_port import Port from pyof.v0x01.common.queue import ListOfQueues from pyof.v0x01.foundation.base import GenericMessage from pyof.v0x01.foundation.basic_types import PAD, UBInt16 __all__ = ('QueueGetConfigReply',) class QueueGetConfigReply(GenericMessage): """Class implements the response to the config request.""" header = Header( message_type=Type.OFPT_GET_CONFIG_REPLY) port = UBInt16(enum_ref=Port) #: Pad to 64-bits. pad = PAD(6) queues = ListOfQueues() def __init__(self, xid=None, port=None, queues=None): """The constructor just assings parameters to object attributes. Args: xid (int): xid of OpenFlow header. port (Port): Target port for the query. queue (ListOfQueues): List of configured queues. """ super().__init__(xid) self.port = port self.queues = [] if queues is None else queues python-openflow-1.1.0-alpha2/pyof/v0x01/controller2switch/queue_get_config_request.py000066400000000000000000000016201275711427400310130ustar00rootroot00000000000000"""Query the switch for configured queues on a port.""" # System imports # Third-party imports # Local source tree imports from pyof.v0x01.common.header import Header, Type from pyof.v0x01.common.phy_port import Port from pyof.v0x01.foundation.base import GenericMessage from pyof.v0x01.foundation.basic_types import PAD, UBInt16 __all__ = ('QueueGetConfigRequest',) class QueueGetConfigRequest(GenericMessage): """Query structure for configured queues on a port.""" header = Header(message_type=Type.OFPT_GET_CONFIG_REQUEST) port = UBInt16(enum_ref=Port) #: Pad to 64-bits pad = PAD(2) def __init__(self, xid=None, port=None): """The constructor just assings parameters to object attributes. Args: xid (int): xid of OpenFlow header port (Port): Target port for the query """ super().__init__(xid) self.port = port python-openflow-1.1.0-alpha2/pyof/v0x01/controller2switch/set_config.py000066400000000000000000000015451275711427400260610ustar00rootroot00000000000000"""Define SetConfig message.""" # System imports # Third-party imports # Local imports from pyof.v0x01.common.header import Type from pyof.v0x01.controller2switch.common import SwitchConfig __all__ = ('SetConfig',) class SetConfig(SwitchConfig): """Set config message.""" def __init__(self, xid=None, flags=None, miss_send_len=None): """The constructor just assings parameters to object attributes. Args: xid (int): xid to be used on the message header. flags (ConfigFlags): OFPC_* flags. miss_send_len (int): UBInt16 max bytes of new flow that the datapath should send to the controller. """ self.__ordered__ = super().__ordered__ # pylint: disable=no-member super().__init__(xid, flags, miss_send_len) self.header.message_type = Type.OFPT_SET_CONFIG python-openflow-1.1.0-alpha2/pyof/v0x01/controller2switch/stats_reply.py000066400000000000000000000022331275711427400263050ustar00rootroot00000000000000"""Response the stat request packet from the controller.""" # System imports # Third-party imports # Local imports from pyof.v0x01.common.header import Header, Type from pyof.v0x01.controller2switch.common import StatsTypes from pyof.v0x01.foundation.base import GenericMessage from pyof.v0x01.foundation.basic_types import ConstantTypeList, UBInt16 __all__ = ('StatsReply',) # Classes class StatsReply(GenericMessage): """Class implements the response to the config request.""" #: OpenFlow :class:`.Header` header = Header(message_type=Type.OFPT_STATS_REPLY) body_type = UBInt16(enum_ref=StatsTypes) flags = UBInt16() body = ConstantTypeList() def __init__(self, xid=None, body_type=None, flags=None, body=None): """The constructor just assings parameters to object attributes. Args: body_type (StatsTypes): One of the OFPST_* constants. flags (int): OFPSF_REQ_* flags (none yet defined). body (ConstantTypeList): Body of the request. """ super().__init__(xid) self.body_type = body_type self.flags = flags self.body = [] if body is None else body python-openflow-1.1.0-alpha2/pyof/v0x01/controller2switch/stats_request.py000066400000000000000000000021671275711427400266500ustar00rootroot00000000000000"""Query the datapath about its current state.""" # System imports # Third-party imports # Local imports from pyof.v0x01.common.header import Header, Type from pyof.v0x01.controller2switch.common import StatsTypes from pyof.v0x01.foundation.base import GenericMessage from pyof.v0x01.foundation.basic_types import ConstantTypeList, UBInt16 __all__ = ('StatsRequest',) class StatsRequest(GenericMessage): """Response to the config request.""" #: OpenFlow :class:`.Header` header = Header(message_type=Type.OFPT_STATS_REQUEST) body_type = UBInt16(enum_ref=StatsTypes) flags = UBInt16() body = ConstantTypeList() def __init__(self, xid=None, body_type=None, flags=None, body=None): """The constructor just assings parameters to object attributes. Args: body_type (StatsTypes): One of the OFPST_* constants. flags (int): OFPSF_REQ_* flags (none yet defined). body (ConstantTypeList): Body of the request. """ super().__init__(xid) self.body_type = body_type self.flags = flags self.body = [] if body is None else body python-openflow-1.1.0-alpha2/pyof/v0x01/foundation/000077500000000000000000000000001275711427400220415ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/pyof/v0x01/foundation/__init__.py000066400000000000000000000001621275711427400241510ustar00rootroot00000000000000"""Foundation package is the base of python-openflow. It provides modules used throughout the whole library. """ python-openflow-1.1.0-alpha2/pyof/v0x01/foundation/base.py000066400000000000000000000475171275711427400233430ustar00rootroot00000000000000"""Base and fundamental classes used all over the library. Besides classes, several constants are defined here. We designed python-openflow in a manner to make it easy to create new messages and OpenFlow structs. You can realize that when you see a message class definition. A **struct** here is a group of basic attributes and/or struct attributes (i.e. :class:`~.common.header.Header`). A **message** here is like a struct, but all messages have a header attribute (i.e. :class:`~.asynchronous.packet_in.PacketIn`). The main classes of this module are :class:`GenericStruct`, :class:`GenericMessage`, :class:`GenericBitMask` and :class:`GenericType`. These classes are used in all parts of this library. """ # System imports import struct from collections import OrderedDict from copy import deepcopy from enum import Enum # Local source tree imports from pyof.v0x01.foundation import exceptions # Third-party imports # This will determine the order on sphinx documentation. __all__ = ('GenericStruct', 'GenericMessage', 'GenericType', 'GenericBitMask', 'MetaStruct', 'MetaBitMask') # Constants OFP_ETH_ALEN = 6 OFP_MAX_PORT_NAME_LEN = 16 OFP_VERSION = 0x01 OFP_MAX_TABLE_NAME_LEN = 32 SERIAL_NUM_LEN = 32 DESC_STR_LEN = 256 # Classes class GenericType: """This is a foundation class for all custom attributes. Base class for :class:`~.UBInt8`, :class:`~.Char` and others. """ _fmt = None def __init__(self, value=None, enum_ref=None): """The constructor takes the optional parameters below. Args: value: The type's value. enum_ref (:class:`type`): If :attr:`value` is from an Enum, specify its type. """ self._value = value self.enum_ref = enum_ref def __repr__(self): return "{}({})".format(type(self).__name__, self._value) def __str__(self): return '{}'.format(str(self._value)) def __eq__(self, other): if isinstance(other, self.__class__): return self.pack() == other.pack() elif self.isenum() and isinstance(other, self.enum_ref): return self.value == other.value return self.value == other def __ne__(self, other): return self._value != other def __gt__(self, other): return self._value > other def __ge__(self, other): return self._value >= other def __lt__(self, other): return self._value <= other def __le__(self, other): return self._value <= other def __add__(self, other): return self.value + other def __sub__(self, other): return self.value - other @property def value(self): """Return this type's value. The value of an enum, bitmask, etc. """ if self.isenum(): if isinstance(self._value, self.enum_ref): return self._value.value return self._value elif self.is_bitmask(): return self._value.bitmask else: return self._value def pack(self, value=None): """Pack the value as a binary representation. Considering an example with UBInt8 class, that inherits from GenericType: .. code-block:: python3 objectA = UBInt8(1) objectB = 5 objectA.pack() >>> b'\x01' objectA.pack(objectB) >>> b'\x05' Args: value: If the value is None, then we will pack the value of the current instance. Otherwise, if value is an instance of the same type as the current instance, then we call the pack of the value object. Otherwise, we will use the current instance pack method on the passed value. Returns: bytes: The binary representation. Raises: :exc:`~.exceptions.BadValueException`: If the value does not fit the binary format. """ if isinstance(value, type(self)): return value.pack() if value is None: value = self.value elif 'value' in dir(value): # if it is enum or bitmask gets only the 'int' value value = value.value try: return struct.pack(self._fmt, value) except struct.error: msg = '{} could not pack {} = {}.'.format(type(self).__name__, type(value).__name__, value) raise exceptions.PackException(msg) def unpack(self, buff, offset=0): """Unpack *buff* into this object. This method will convert a binary data into a readable value according to the attribute format. Args: buff (bytes): Binary buffer. offset (int): Where to begin unpacking. Raises: :exc:`~.exceptions.UnpackException`: If unpack fails. """ try: self._value = struct.unpack_from(self._fmt, buff, offset)[0] if self.enum_ref: self._value = self.enum_ref(self._value) except struct.error: msg = 'fmt: {}, buff: {}, offset: {}.'.format( self._fmt, buff, offset) raise exceptions.UnpackException(msg) def get_size(self, value=None): """Return the size in bytes of this type. Returns: int: Size in bytes. """ return struct.calcsize(self._fmt) def is_valid(self): """Check whether the value fits the binary format. Assert that :func:`pack` succeeds. Returns: bool: Whether the value is valid for this type. """ try: self.pack() return True except exceptions.BadValueException: return False def isenum(self): """Test whether it is an :class:`~Enum`. Returns: bool: Whether it is an :class:`~Enum`. """ return self.enum_ref and issubclass(self.enum_ref, Enum) def is_bitmask(self): """Test whether it is a :class:`GenericBitMask`. Returns: bool: Whether it is a :class:`GenericBitMask`. """ return self._value and issubclass(type(self._value), GenericBitMask) class MetaStruct(type): """MetaClass to force ordered attributes. You probably do not need to use this class. Inherit from :class:`GenericStruct` instead. """ @classmethod def __prepare__(mcs, name, bases): # pylint: disable=unused-argument return OrderedDict() def __new__(mcs, name, bases, classdict): """Add ``__ordered__`` attribute with attributes in declared order.""" # Skip methods and private attributes classdict['__ordered__'] = OrderedDict([(key, type(value)) for key, value in classdict.items() if key[0] != '_' and not hasattr(value, '__call__')]) return type.__new__(mcs, name, bases, classdict) class GenericStruct(object, metaclass=MetaStruct): """Class inherited by all OpenFlow structs. If you need to insert a method that will be used by all structs, this is the place to code it. .. note:: A struct on this library's context is like a struct in C. It has a list of attributes and theses attributes can be structs, too. """ def __init__(self): """Contructor takes no argument and stores attributes' deep copies.""" for attribute_name, class_attribute in self.get_class_attributes(): setattr(self, attribute_name, deepcopy(class_attribute)) def __eq__(self, other): """Check whether two structures have the same structure and values. Compare the binary representation of structs to decide whether they are equal or not. Args: other (GenericStruct): The struct to be compared with. """ return self.pack() == other.pack() @staticmethod def _attr_fits_into_class(attr, cls): if not isinstance(attr, cls): try: struct.pack(cls._fmt, attr) except struct.error: return False return True # linter cannot detect attribute added by metaclass # pylint: disable=no-member def _validate_attributes_type(self): """Validate the type of each attribute.""" for _attr in self.__ordered__: _class = self.__ordered__[_attr] attr = getattr(self, _attr) if isinstance(attr, _class): return True elif issubclass(_class, GenericType): if GenericStruct._attr_fits_into_class(attr, _class): return True elif not isinstance(attr, _class): return False return True def get_class_attributes(self): """Return a generator for class attributes' names and their types. .. code-block:: python3 for _name, _type in self.get_class_attributes(): print("Attribute name: {}".format(_name)) print("Attribute type: {}".format(_type)) Returns: generator: Tuples with attribute name and type. """ for attribute_name in self.__ordered__: # pylint: disable=no-member yield (attribute_name, getattr(type(self), attribute_name)) def get_instance_attributes(self): """Return a generator for instance attributes' names and their values. .. code-block:: python3 for _name, _value in self.get_instance_attributes(): print("Attribute name: {}".format(_name)) print("Attribute value: {}".format(_value)) Returns: generator: Tuples with attribute name and value. """ for attribute_name in self.__ordered__: # pylint: disable=no-member yield (attribute_name, getattr(self, attribute_name)) def get_attributes(self): """Return a generator for instance and class attribute. .. code-block:: python3 for instance_attribute, class_attribute in self.get_attributes(): print("Instance Attribute: {}".format(instance_attribute)) print("Class Attribute: {}".format(class_attribute)) Returns: generator: Tuples with instance attribute and class attribute """ for attribute_name in self.__ordered__: # pylint: disable=no-member yield (getattr(self, attribute_name), getattr(type(self), attribute_name)) def get_size(self, value=None): """Calculate the total struct size in bytes. For each struct attribute, sum the result of each one's ``get_size()`` method. Args: value: In structs, the user can assign other value instead of a class' instance. Returns: int: Total number of bytes used by the struct. Raises: Exception: If the struct is not valid. """ if value is None: return sum(cls.get_size(obj) for obj, cls in self.get_attributes()) elif isinstance(value, type(self)): return value.get_size() else: msg = "{} is not an instance of {}".format(value, type(self).__name__) raise exceptions.PackException(msg) def pack(self, value=None): """Pack the struct in a binary representation. Iterate over the class attributes, according to the order of definition, and then convert each attribute to its byte representation using its own ``pack`` method. Returns: bytes: Binary representation of the struct object. Raises: :exc:`~.exceptions.ValidationError`: If validation fails. """ if value is None: if not self.is_valid(): error_msg = "Error on validation prior to pack() on class " error_msg += "{}.".format(type(self).__name__) raise exceptions.ValidationError(error_msg) else: message = b'' # pylint: disable=no-member for instance_attr, class_attr in self.get_attributes(): message += class_attr.pack(instance_attr) return message elif isinstance(value, type(self)): return value.pack() else: msg = "{} is not an instance of {}".format(value, type(self).__name__) raise exceptions.PackException(msg) def unpack(self, buff, offset=0): """Unpack a binary struct into this object's attributes. Update this object attributes based on the unpacked values of *buff*. It is an inplace method and it receives the binary data of the struct. Args: buff (bytes): Binary data package to be unpacked. offset (int): Where to begin unpacking. """ begin = offset for attribute_name, class_attribute in self.get_class_attributes(): attribute = deepcopy(class_attribute) try: attribute.unpack(buff, begin) except exceptions.UnpackException: msg = 'Attribute name: {}, type: {}.'.format( attribute_name, type(class_attribute).__name__) raise exceptions.UnpackException(msg) setattr(self, attribute_name, attribute) begin += attribute.get_size() def is_valid(self): """Check whether all struct attributes in are valid. This method will check whether all struct attributes have a proper value according to the OpenFlow specification. For instance, if you have a struct with an attribute of type :class:`UBInt8()` and you assign a string value to it, this method will return False. Returns: bool: Whether the struct is valid. """ return True if not self._validate_attributes_type(): return False return True class GenericMessage(GenericStruct): """Base class that is the foundation for all OpenFlow messages. To add a method that will be used by all messages, write it here. .. note:: A Message on this library context is like a Struct but has a also a :attr:`header` attribute. """ header = None def __init__(self, xid): """Initialize header's xid.""" super().__init__() if xid is not None: self.header.xid = xid def unpack(self, buff, offset=0): """Unpack a binary message into this object's attributes. Unpack the binary value *buff* and update this object attributes based on the results. It is an inplace method and it receives the binary data of the message **without the header**. Args: buff (bytes): Binary data package to be unpacked, without the header. offset (int): Where to begin unpacking. """ begin = offset for attribute_name, class_attribute in self.get_class_attributes(): if type(class_attribute).__name__ != "Header": attribute = deepcopy(class_attribute) attribute.unpack(buff, begin) setattr(self, attribute_name, attribute) begin += attribute.get_size() def _validate_message_length(self): if not self.header.length == self.get_size(): return False return True def is_valid(self): """Check whether a message is valid or not. This method will validate the Message content. During the validation process, we check whether the attributes' values are valid according to the OpenFlow specification. Call this method if you want to verify whether the message is ready to pack. Returns: bool: Whether the message is valid. """ return True if not super().is_valid(): return False if not self._validate_message_length(): return False return True def pack(self, value=None): """Pack the message into a binary data. One of the basic operations on a Message is the pack operation. During the packing process, we convert all message attributes to binary format. Since that this is usually used before sending the message to a switch, here we also call :meth:`update_header_length`. .. seealso:: This method call its parent's :meth:`GenericStruct.pack` after :meth:`update_header_length`. Returns: bytes: A binary data thats represents the Message. Raises: Exception: If there are validation errors. """ if value is None: self.update_header_length() return super().pack() elif isinstance(value, type(self)): return value.pack() else: msg = "{} is not an instance of {}".format(value, type(self).__name__) raise exceptions.PackException(msg) def update_header_length(self): """Update the header length attribute based on current message size. When sending an OpenFlow message we need to inform the message length on the header. This is mandatory. """ self.header.length = self.get_size() class MetaBitMask(type): """MetaClass to create a special BitMaskEnum type. You probably do not need to use this class. Inherit from :class:`GenericBitMask` instead. This metaclass converts the declared class attributes into elements of an enum. It also replaces the :meth:`__dir__` and :meth:`__getattr__` methods, so the resulting class will behave as an :class:`~Enum` class (you can access object.ELEMENT and recover either values or names). """ def __new__(mcs, name, bases, classdict): """Convert class attributes into enum elements.""" _enum = OrderedDict([(key, value) for key, value in classdict.items() if key[0] != '_' and not hasattr(value, '__call__') and not isinstance(value, property)]) if _enum: classdict = {key: value for key, value in classdict.items() if key[0] == '_' or hasattr(value, '__call__') or isinstance(value, property)} classdict['_enum'] = _enum return type.__new__(mcs, name, bases, classdict) def __getattr__(cls, name): return cls._enum[name] def __dir__(cls): res = dir(type(cls)) + list(cls.__dict__.keys()) if cls is not GenericBitMask: res.extend(cls._enum) return res class GenericBitMask(object, metaclass=MetaBitMask): """Base class for enums that use bitmask values.""" def __init__(self, bitmask=None): """The constructor has the optional parameter below. Args: bitmask: Bitmask value. """ self.bitmask = bitmask self._enum = {} def __str__(self): return "{}".format(self.bitmask) def __repr__(self): return "{}({})".format(type(self).__name__, self.bitmask) @property def names(self): """List of selected enum names. Returns: list: Enum names. """ result = [] for key, value in self.iteritems(): if value & self.bitmask: result.append(key) return result def iteritems(self): """Generator for attributes' name-value pairs. Returns: generator: Attributes' (name, value) tuples. """ for key, value in self._enum.items(): yield (key, value) python-openflow-1.1.0-alpha2/pyof/v0x01/foundation/basic_types.py000066400000000000000000000407271275711427400247320ustar00rootroot00000000000000"""Basic types used in structures and messages.""" # System imports import struct # Local source tree imports from pyof.v0x01.foundation import exceptions from pyof.v0x01.foundation.base import GenericStruct, GenericType # Third-party imports __all__ = ('UBInt8', 'UBInt16', 'UBInt32', 'UBInt64', 'Char', 'PAD', 'HWAddress', 'BinaryData', 'FixedTypeList', 'ConstantTypeList') class PAD(GenericType): """Class for padding attributes.""" _fmt = '' def __init__(self, length=0): """Pad up to ``length``, in bytes. Args: length (int): Total length, in bytes. """ super().__init__() self._length = length def __repr__(self): return "{}({})".format(type(self).__name__, self._length) def __str__(self): return self.pack() def get_size(self, value=None): """Return the type size in bytes. Args: value (int): In structs, the user can assign other value instead of this class' instance. Here, in such cases, ``self`` is a class attribute of the struct. Returns: int: Size in bytes. """ return self._length def unpack(self, buff, offset=0): """Unpack *buff* into this object. Do nothing, since the _length is already defined and it is just a PAD. Keep buff and offset just for compability with other unpack methods. Args: buff: Buffer where data is located. offset (int): Where data stream begins. """ pass def pack(self, value=None): """Pack the object. Args: value (int): In structs, the user can assign other value instead of this class' instance. Here, in such cases, ``self`` is a class attribute of the struct. Returns: bytes: the byte 0 (zero) *length* times. """ return b'\x00' * self._length class UBInt8(GenericType): """Format character for an Unsigned Char. Class for an 8-bit (1-byte) Unsigned Integer. """ _fmt = "!B" class UBInt16(GenericType): """Format character for an Unsigned Short. Class for an 16-bit (2-byte) Unsigned Integer. """ _fmt = "!H" class UBInt32(GenericType): """Format character for an Unsigned Int. Class for an 32-bit (4-byte) Unsigned Integer. """ _fmt = "!I" class UBInt64(GenericType): """Format character for an Unsigned Long Long. Class for an 64-bit (8-byte) Unsigned Integer. """ _fmt = "!Q" class Char(GenericType): """Build a double char type according to the length.""" def __init__(self, value=None, length=0): """The constructor takes the optional parameters below. Args: value: The character to be build. length (int): Character size. """ super().__init__(value) self.length = length self._fmt = '!{}{}'.format(self.length, 's') def pack(self, value=None): """Pack the value as a binary representation. Returns: bytes: The binary representation. Raises: struct.error: If the value does not fit the binary format. """ if isinstance(value, type(self)): return value.pack() try: if value is None: value = self.value packed = struct.pack(self._fmt, bytes(value, 'ascii')) return packed[:-1] + b'\0' # null-terminated except struct.error as err: msg = "Char Pack error. " msg += "Class: {}, struct error: {} ".format(type(value).__name__, err) raise exceptions.PackException(msg) def unpack(self, buff, offset=0): """Unpack a binary message into this object's attributes. Unpack the binary value *buff* and update this object attributes based on the results. Args: buff (bytes): Binary data package to be unpacked. offset (int): Where to begin unpacking. Raises: Exception: If there is a struct unpacking error. """ try: begin = offset end = begin + self.length unpacked_data = struct.unpack(self._fmt, buff[begin:end])[0] except struct.error: raise Exception("%s: %s" % (offset, buff)) self._value = unpacked_data.decode('ascii').rstrip('\0') class HWAddress(GenericType): """Defines a hardware address.""" def __init__(self, hw_address='00:00:00:00:00:00'): """The constructor takes the parameters below. Args: hw_address (bytes): Hardware address. Defaults to '00:00:00:00:00:00'. """ super().__init__(hw_address) def pack(self, value=None): """Pack the value as a binary representation. Returns bytes: The binary representation. Raises: struct.error: If the value does not fit the binary format. """ if isinstance(value, type(self)): return value.pack() if value is not None: value = value.split(':') else: value = self._value.split(':') try: return struct.pack('!6B', *[int(x, 16) for x in value]) except struct.error as err: msg = "HWAddress error. " msg += "Class: {}, struct error: {} ".format(type(value).__name__, err) raise exceptions.PackException(msg) def unpack(self, buff, offset=0): """Unpack a binary message into this object's attributes. Unpack the binary value *buff* and update this object attributes based on the results. Args: buff (bytes): Binary data package to be unpacked. offset (int): Where to begin unpacking. Raises: Exception: If there is a struct unpacking error. """ def _int2hex(n): h = hex(n)[2:] # remove '0x' prefix if len(h) == 1: return '0' + h else: return h try: unpacked_data = struct.unpack('!6B', buff[offset:offset+6]) except: raise Exception("%s: %s" % (offset, buff)) transformed_data = ':'.join([_int2hex(x) for x in unpacked_data]) self._value = transformed_data def get_size(self, value=None): """Return the address size in bytes. Args: value: In structs, the user can assign other value instead of this class' instance. Here, in such cases, ``self`` is a class attribute of the struct. Returns: int: The address size in bytes. """ return 6 class BinaryData(GenericType): """Class to create objects that represent binary data. This is used in the ``data`` attribute from :class:`.PacketIn` and :class:`.PacketOut` messages. Both the :meth:`pack` and :meth:`unpack` methods will return the binary data itself. :meth:`get_size` method will return the size of the instance using Python's :func:`len`. """ def __init__(self, value=b''): """The constructor takes the parameter below. Args: value (bytes): The binary data. Defaults to an empty value. """ super().__init__(value) def pack(self, value=None): """Pack the value as a binary representation. Returns: bytes: The binary representation. Raises: :exc:`~.exceptions.NotBinaryData`: If value is not :class:`bytes`. """ if isinstance(value, type(self)): return value.pack() if value is None: value = self._value if isinstance(value, bytes) and len(value) > 0: return value else: return b'' def unpack(self, buff, offset=0): """Unpack a binary message into this object's attributes. Unpack the binary value *buff* and update this object attributes based on the results. Since the *buff* is binary data, no conversion is done. Args: buff (bytes): Binary data package to be unpacked. offset (int): Where to begin unpacking. """ self._value = buff def get_size(self, value=None): """Return the size in bytes. Args: value (bytes): In structs, the user can assign other value instead of this class' instance. Here, in such cases, ``self`` is a class attribute of the struct. Returns: int: The address size in bytes. """ if value is None: return len(self._value) elif isinstance(value, type(self)): return value.get_size() else: return len(value) class TypeList(list, GenericStruct): """Base class for lists that store objects of one single type.""" def __init__(self, items): """Initialize the list with one item or a list of items. Args: items (iterable, ``pyof_class``): Items to be stored. """ super().__init__() if isinstance(items, list): self.extend(items) elif items: self.append(items) def extend(self, items): """Extend the list by adding all items of ``items``. Args: items (iterable): Items to be added to the list. Raises: :exc:`~.exceptions.WrongListItemType`: If an item has an unexpected type. """ for item in items: self.append(item) def pack(self, value=None): """Pack the value as a binary representation. Returns: bytes: The binary representation. """ if isinstance(value, type(self)): return value.pack() if value is None: value = self else: container = type(self)() container.extend(value) value = container bin_message = b'' try: for item in value: bin_message += item.pack() return bin_message except exceptions.PackException as err: msg = "{} pack error: {}".format(type(self).__name__, err) raise exceptions.PackException(msg) def unpack(self, buff, item_class, offset=0): """Unpack the elements of the list. This unpack method considers that all elements have the same size. To use this class with a pyof_class that accepts elements with different sizes, you must reimplement the unpack method. Args: buff (bytes): The binary data to be unpacked. item_class (:obj:`type`): Class of the expected items on this list. offset (int): If we need to shift the beginning of the data. """ item_size = item_class().get_size() binary_items = (buff[i:i+item_size] for i in range(offset, len(buff), item_size)) for binary_item in binary_items: item = item_class() item.unpack(binary_item) self.append(item) def get_size(self, value=None): """Return the size in bytes. Args: value: In structs, the user can assign other value instead of this class' instance. Here, in such cases, ``self`` is a class attribute of the struct. Returns: int: The size in bytes. """ if value is None: if len(self) == 0: # If this is a empty list, then returns zero return 0 elif issubclass(type(self[0]), GenericType): # If the type of the elements is GenericType, then returns the # length of the list multiplied by the size of the GenericType. return len(self) * self[0].get_size() else: # Otherwise iter over the list accumulating the sizes. return sum(item.get_size() for item in self) else: return type(self)(value).get_size() def __str__(self): """Human-readable object representantion.""" return "{}".format([str(item) for item in self]) class FixedTypeList(TypeList): """A list that stores instances of one pyof class.""" _pyof_class = None def __init__(self, pyof_class, items=None): """The constructor parameters follows. Args: pyof_class (:obj:`type`): Class of the items to be stored. items (iterable, ``pyof_class``): Items to be stored. """ self._pyof_class = pyof_class super().__init__(items) def append(self, item): """Append one item to the list. Args: item: Item to be appended. Its type must match the one defined in the constructor. Raises: :exc:`~.exceptions.WrongListItemType`: If the item has a different type than the one specified in the constructor. """ if isinstance(item, list): self.extend(item) elif item.__class__ == self._pyof_class: list.append(self, item) else: raise exceptions.WrongListItemType(item.__class__.__name__, self._pyof_class.__name__) def insert(self, index, item): """Insert an item at the specified index. Args: index (int): Position to insert the item. item: Item to be inserted. It must have the type specified in the constructor. Raises: :exc:`~.exceptions.WrongListItemType`: If the item has a different type than the one specified in the constructor. """ if item.__class__ == self._pyof_class: list.insert(self, index, item) else: raise exceptions.WrongListItemType(item.__class__.__name__, self._pyof_class.__name__) def unpack(self, buff, offset=0): """Unpack the elements of the list. This unpack method considers that all elements have the same size. To use this class with a pyof_class that accepts elements with different sizes, you must reimplement the unpack method. Args: buff (bytes): The binary data to be unpacked. offset (int): If we need to shift the beginning of the data. """ super().unpack(buff, self._pyof_class, offset) class ConstantTypeList(TypeList): """List that contains only objects of the same type (class). The types of all items are expected to be the same as the first item's. Otherwise, :exc:`~.exceptions.WrongListItemType` is raised in many list operations. """ def __init__(self, items=None): """The contructor can contain the items to be stored. Args: items (iterable, :class:`object`): Items to be stored. Raises: :exc:`~.exceptions.WrongListItemType`: If an item has a different type than the first item to be stored. """ super().__init__(items) def append(self, item): """Append one item to the list. Args: item: Item to be appended. Raises: :exc:`~.exceptions.WrongListItemType`: If an item has a different type than the first item to be stored. """ if isinstance(item, list): self.extend(item) elif len(self) == 0: list.append(self, item) elif item.__class__ == self[0].__class__: list.append(self, item) else: raise exceptions.WrongListItemType(item.__class__.__name__, self[0].__class__.__name__) def insert(self, index, item): """Insert an item at the specified index. Args: index (int): Position to insert the item. item: Item to be inserted. Raises: :exc:`~.exceptions.WrongListItemType`: If an item has a different type than the first item to be stored. """ if len(self) == 0: list.append(self, item) elif item.__class__ == self[0].__class__: list.insert(self, index, item) else: raise exceptions.WrongListItemType(item.__class__.__name__, self[0].__class__.__name__) python-openflow-1.1.0-alpha2/pyof/v0x01/foundation/exceptions.py000066400000000000000000000035031275711427400245750ustar00rootroot00000000000000"""Exceptions raised by this library.""" class ValidationError(Exception): """Can be used directly or inherited by mpre specific validation errors.""" def __str__(self): return "Validation error: " + super().__str__() class MethodNotImplemented(Exception): """Exception to be raised when a method is not implemented.""" def __str__(self): return "Method not yet implemented" + super().__str__() class BadValueException(Exception): """Attribute has an unexpected value.""" def __str__(self): return "BadValue error: " + super().__str__() class WrongListItemType(Exception): """When an item of a wrong type is inserted into a list. Exception used by :class:`.FixedTypeList` and :class:`.ConstantTypeList` when the user tries to insert an item that does not match the expected type. """ def __init__(self, item_class, expected_class): """The constructor takes parameters to inform the user about the error. Args: item_class (:obj:`type`): The class of the item that was being inserted in the list when the exception was raised. expected_class (:obj:`type`): The expected type that didn't match against the item to be inserted. """ super().__init__() self.item_class = item_class self.expected_class = expected_class def __str__(self): return "'{}' is not an instance of {}".format(self.item_class, self.expected_class) class UnpackException(Exception): """Error while unpacking.""" def __str__(self): return "Unpack error: " + super().__str__() class PackException(Exception): """Error while unpacking.""" def __str__(self): return "Pack error: " + super().__str__() python-openflow-1.1.0-alpha2/pyof/v0x01/symmetric/000077500000000000000000000000001275711427400217075ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/pyof/v0x01/symmetric/__init__.py000066400000000000000000000000321275711427400240130ustar00rootroot00000000000000"""Symmetric Messages.""" python-openflow-1.1.0-alpha2/pyof/v0x01/symmetric/echo_reply.py000066400000000000000000000012561275711427400244160ustar00rootroot00000000000000"""Defines Echo Reply message during the handshake.""" # System imports # Third-party imports from pyof.v0x01.common.header import Header, Type from pyof.v0x01.foundation.base import GenericMessage __all__ = ('EchoReply',) # Classes class EchoReply(GenericMessage): """OpenFlow Reply message. This message does not contain a body beyond the OpenFlow Header. """ header = Header(message_type=Type.OFPT_ECHO_REPLY, length=8) def __init__(self, xid=None): """The constructor takes the parameters below. Args: xid (int): xid to be used on the message header. """ super().__init__(xid) python-openflow-1.1.0-alpha2/pyof/v0x01/symmetric/echo_request.py000066400000000000000000000012271275711427400247510ustar00rootroot00000000000000"""Defines Echo Request message during the handshake.""" # System imports # Third-party imports from pyof.v0x01.common.header import Header, Type from pyof.v0x01.foundation.base import GenericMessage __all__ = ('EchoRequest',) # Classes class EchoRequest(GenericMessage): """OpenFlow Reply message. This message does not contain a body after the OpenFlow Header. """ header = Header(message_type=Type.OFPT_ECHO_REQUEST, length=8) def __init__(self, xid=None): """The constructor takes the parameters below. Args: xid (int): xid to be used on the message header. """ super().__init__(xid) python-openflow-1.1.0-alpha2/pyof/v0x01/symmetric/hello.py000066400000000000000000000011511275711427400233620ustar00rootroot00000000000000"""Defines Hello message.""" # System imports # Third-party imports from pyof.v0x01.common.header import Header, Type from pyof.v0x01.foundation.base import GenericMessage __all__ = ('Hello',) # Classes class Hello(GenericMessage): """OpenFlow Hello Message. This message does not contain a body beyond the OpenFlow Header. """ header = Header(message_type=Type.OFPT_HELLO, length=8) def __init__(self, xid=None): """The constructor takes the parameters below. Args: xid (int): xid to be used on the message header. """ super().__init__(xid) python-openflow-1.1.0-alpha2/pyof/v0x01/symmetric/vendor_header.py000066400000000000000000000015731275711427400250740ustar00rootroot00000000000000"""Defines Vendor message.""" # System imports # Third-party imports from pyof.v0x01.common.header import Header, Type from pyof.v0x01.foundation.base import GenericMessage from pyof.v0x01.foundation.basic_types import UBInt32 __all__ = ('VendorHeader',) # Classes class VendorHeader(GenericMessage): """OpenFlow Vendor message. This message does not contain a body beyond the OpenFlow Header. """ header = Header(message_type=Type.OFPT_VENDOR) vendor = UBInt32() def __init__(self, xid=None, vendor=None): """The constructor takes the parameters below. Args: xid (int): xid to be used on the message header. vendor (int): Vendor ID: MSB 0: low-order bytes are IEEE OUI. MSB != 0: defined by OpenFlow consortium. """ super().__init__(xid) self.vendor = vendor python-openflow-1.1.0-alpha2/pyof/v0x02/000077500000000000000000000000001275711427400176745ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/pyof/v0x02/__init__.py000066400000000000000000000000701275711427400220020ustar00rootroot00000000000000"""The ofx parser package - spec version 0x02 (1.1).""" python-openflow-1.1.0-alpha2/pyof/v0x02/common/000077500000000000000000000000001275711427400211645ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/pyof/v0x02/common/__init__.py000066400000000000000000000000561275711427400232760ustar00rootroot00000000000000"""Common Messages from OpenFlow Protocol.""" python-openflow-1.1.0-alpha2/raw/000077500000000000000000000000001275711427400166315ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/raw/README.rst000066400000000000000000000013341275711427400203210ustar00rootroot00000000000000Generating raw dump files ========================= 1. POX - version 0.2.0 (carp), cloned from `GitHub `_: a. ``./pox.py openflow.of_01 --address=127.0.0.1 --port=6633 py`` 1. Wireshark - version 2.0.4 with `openflow plugin `_: a. Choose *loopback* interface; a. Filter by *of*; a. Start capturing; a. After running Mininet as described below, in order to save the OpenFlow content in a dump file, right click in the *OpenFlow* tree and then *Export Selected Bytes...*. All done! 1. Mininet - version 2.2.1 a. ``sudo mn --controller=remote,ip='127.0.0.1',listenport=6633 --switch ovs,protocols=OpenFlow10`` python-openflow-1.1.0-alpha2/raw/v0x01/000077500000000000000000000000001275711427400175075ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/raw/v0x01/ofpt_barrier_reply.dat000066400000000000000000000000101275711427400240610ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/raw/v0x01/ofpt_barrier_request.dat000066400000000000000000000000101275711427400244160ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/raw/v0x01/ofpt_echo_reply.dat000066400000000000000000000000101275711427400233510ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/raw/v0x01/ofpt_echo_request.dat000066400000000000000000000000101275711427400237060ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/raw/v0x01/ofpt_features_reply.dat000066400000000000000000000002601275711427400242600ustar00rootroot00000000000000°þÇÿÿþÓ˜¥0Gs1 TÏüNms1-eth1Àö¶«ÌøOs1-eth2Àpython-openflow-1.1.0-alpha2/raw/v0x01/ofpt_features_request.dat000066400000000000000000000000101275711427400246060ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/raw/v0x01/ofpt_flow_add.dat000066400000000000000000000001201275711427400230010ustar00rootroot00000000000000P# ˆÌýèÿÿÿÿÿÿÿýÿÿpython-openflow-1.1.0-alpha2/raw/v0x01/ofpt_flow_delete.dat000066400000000000000000000001101275711427400235120ustar00rootroot00000000000000H€ÿÿÿÿÿÿpython-openflow-1.1.0-alpha2/raw/v0x01/ofpt_hello.dat000066400000000000000000000000101275711427400223230ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/raw/v0x01/ofpt_packet_in.dat000066400000000000000000000000741275711427400231670ustar00rootroot00000000000000 <*ÿÿÿÿÿÿJ®ãpèJ®ãpè  python-openflow-1.1.0-alpha2/raw/v0x01/ofpt_packet_out.dat000066400000000000000000000001011275711427400233570ustar00rootroot00000000000000 Aÿÿÿÿÿÿ# ÒAÆ.*@ˆÌdpid:11x dpid:1python-openflow-1.1.0-alpha2/raw/v0x01/ofpt_port_status.dat000066400000000000000000000001001275711427400236070ustar00rootroot00000000000000 @šÚŠô s1-eth1Àpython-openflow-1.1.0-alpha2/raw/v0x01/ofpt_set_config.dat000066400000000000000000000000141275711427400233440ustar00rootroot00000000000000 €python-openflow-1.1.0-alpha2/requirements-dev.txt000066400000000000000000000003541275711427400221020ustar00rootroot00000000000000# For developers, the packages below are required. # For running doctests (during "python setup.py test") Sphinx >= 1.4.5 # Linters, also for test pylama >= 7.0.9 pylama-pylint >= 2.2.1 # Code coverage coverage >= 4.1 radon >= 1.4.0 python-openflow-1.1.0-alpha2/requirements-docs.txt000066400000000000000000000005061275711427400222530ustar00rootroot00000000000000# If you want to build and/or update the documentation, the following packages # are required: # Sphinx is required for running doctests (and building documentation) Sphinx >= 1.4.5 # To run "make livehtml", build docs and refresh browser automatically when # files change sphinx-autobuild >= 0.6.0 sphinx-rtd-theme >= 0.1.9 python-openflow-1.1.0-alpha2/requirements.txt000066400000000000000000000002761275711427400213310ustar00rootroot00000000000000# If you only want to use the library, you only need Python >= 3.5. # For python-openflow developers, check requirements-dev.txt. # To update the documentation, check requirements-docs.txt. python-openflow-1.1.0-alpha2/setup.cfg000066400000000000000000000006161275711427400176640ustar00rootroot00000000000000[pep8] exclude = .eggs,ENV,build,docs/conf.py,venv [pylama] linters = pyflakes,isort,pep8,mccabe,pep257,pylint ignore = D105,D203,I0011 # D105: Missing docstring in magic method [pep257] # D203: 1 blank line required before class docstring (found 0) [pep257] # Conflicts with D211: No blank lines allowed before class docstring # I0011: I0011 Locally disabling no-member (E1101) [pylint] python-openflow-1.1.0-alpha2/setup.py000066400000000000000000000051321275711427400175530ustar00rootroot00000000000000"""Setup script. Run "python3 setup --help-commands" to list all available commands and their descriptions. """ import sys from subprocess import call from setuptools import Command, find_packages, setup class Doctest(Command): """Run Sphinx doctest.""" if sys.argv[-1] == 'test': print('Running examples in documentation') call('make doctest -C docs/', shell=True) class Linter(Command): """Run several code linters.""" description = 'Run many code linters. It may take a while' user_options = [] def __init__(self, *args, **kwargs): """Define linters and a message about them.""" super().__init__(*args, **kwargs) self.linters = ['pep257', 'pyflakes', 'mccabe', 'isort', 'pep8', 'pylint'] self.extra_msg = 'It may take a while. For a faster version (and ' \ 'less checks), run "quick_lint".' def initialize_options(self): """For now, options are ignored.""" pass def finalize_options(self): """For now, options are ignored.""" pass def run(self): """Run pylama and radon.""" files = 'tests setup.py pyof' print('running pylama with {}. {}'.format(', '.join(self.linters), self.extra_msg)) cmd = 'pylama -l {} {}'.format(','.join(self.linters), files) call(cmd, shell=True) print('Low grades (<= C) for Cyclomatic Complexity:') call('radon cc --min=C ' + files, shell=True) print('Low grades (<= C) for Maintainability Index:') call('radon mi --min=C ' + files, shell=True) class FastLinter(Linter): """Same as Linter, but without the slow pylint.""" description = 'Same as "lint", but much faster (no pylama_pylint).' def __init__(self, *args, **kwargs): """Remove slow linters and redefine the message about the rest.""" super().__init__(*args, **kwargs) self.linters.remove('pylint') self.extra_msg = 'This a faster version of "lint", without pylint. ' \ 'Run the slower "lint" after solving these issues:' setup(name='python-openflow', version='1.1.0a0', description='Library to parse and generate OpenFlow messages', url='http://github.com/kytos/python-openflow', author='Kytos Team', author_email='of-ng-dev@ncc.unesp.br', license='MIT', test_suite='tests', packages=find_packages(exclude=['tests', '*v0x02*']), cmdclass={ 'lint': Linter, 'quick_lint': FastLinter }, zip_safe=False) python-openflow-1.1.0-alpha2/tests/000077500000000000000000000000001275711427400172025ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/tests/__init__.py000066400000000000000000000000001275711427400213010ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/tests/raw_dump.py000066400000000000000000000030511275711427400213710ustar00rootroot00000000000000"""Help reading raw dump files.""" from pyof.v0x01.common.header import Header from pyof.v0x01.common.utils import new_message_from_header class RawDump: """A helper to deal with paths and reading raw files. Attributes: content (bytes): Raw file's content. """ _HEADER_BYTES = 8 # According to OF Protocol specification def __init__(self, version, basename): """Information to locate the dump file. Args: version (str): OpenFlow protocol version, e.g. ``v0x01``. basename (str): Only the filename without extension. E.g. ``ofpt_echo_reply``. """ self._path = 'raw/{}/{}.dat'.format(version, basename) def read(self): """Read the raw file. Returns: bytes: Raw file's content. """ with open(self._path, 'rb') as file: return file.read() def unpack(self): """Unpack header and message from a byte sequence. Returns: The object type specified in the header with the coresponding header. """ content = self.read() raw_header = content[:self._HEADER_BYTES] header = _unpack_header(raw_header) raw_msg = content[self._HEADER_BYTES:header.length.value] return _unpack_message(header, raw_msg) def _unpack_header(raw_header): header = Header() header.unpack(raw_header) return header def _unpack_message(header, raw_msg): msg = new_message_from_header(header) msg.unpack(raw_msg) return msg python-openflow-1.1.0-alpha2/tests/test_struct.py000066400000000000000000000106751275711427400221500ustar00rootroot00000000000000"""Automate struct tests.""" import unittest from tests.raw_dump import RawDump class TestStruct(unittest.TestCase): """Run tests related to struct packing and unpacking. Test the lib with raw dump files from an OpenFlow switch. We assume the raw files are valid according to the OF specs to check whether our pack and unpack implementations are correct. Also, check the minimum size of the struct by instantiating an object with no parameters. To run these tests, just extends this class and call 2 methods in the ``setUp`` method like the example. Example: .. code-block:: python3 class MyTest(TestDump): @classmethod def setUpClass(cls): super().setUpClass() super().set_raw_dump_file('v0x01', 'ofpt_barrier_reply') # Create BarrierReply(xid=5) when needed super().set_raw_dump_object(BarrierReply, xid=5) # As in spec: ``FP_ASSERT(sizeof(struct ...) == ...);`` super().set_minimum_size(8) """ def __init__(self, *args, **kwargs): """The constructor will avoid that this class tests are executed. The tests in this class are executed through the child, so there's no no need for them to be executed once more through the parent. """ super().__init__(*args, **kwargs) # Override the run method, so it does nothing instead of running the # tests (again). if self.__class__ == TestStruct: self.run = lambda self, *args, **kwargs: None _new_raw_dump = None _new_raw_object = None _msg_cls = None _min_size = None @classmethod def set_raw_dump_file(cls, version, basename): """Set which raw dump the tests will use. Args: protocol_version (str): OpenFlow protocol version, e.g. ``v0x01``. basename (str): The raw filename without extension. E.g. ``ofpt_echo_reply``. """ cls._new_raw_dump = lambda: RawDump(version, basename) @classmethod def get_raw_dump(cls): """Return a new instance of :class:`.RawDump`. Use the parameters set in :meth:`set_raw_dump_file`. Returns: RawDump: with parameters previously set using :meth:`set_raw_dump_file`. """ return cls._new_raw_dump() @classmethod def set_raw_dump_object(cls, msg_cls, *args, **kwargs): """Set how to create the object that is dumped in a raw file. Args: msg_class (:obj:`type`): The message class that is packed as a raw file, followed by its parameters to instantiate an object. Example: ``super().__init__(BarrierReply, xid=5)`` will create ``BarrierReply(xid=5)``. """ TestStruct._msg_cls = msg_cls cls._new_raw_object = lambda: msg_cls(*args, **kwargs) @classmethod def get_raw_object(cls): """Create a new object of the dumped message. Use the class and parameters set in :meth:`set_raw_dump_object`. Returns: A new object using class and parameters priviously set through :meth:`set_raw_dump_object`. """ return cls._new_raw_object() @classmethod def set_minimum_size(cls, size): """Set the struct minimum size. The minimum size can be found in OF spec. For example, :class:`.PhyPort` minimum size is 48 because of ``FP_ASSERT(sizeof(struct ofp_phy_port) == 48);`` (spec 1.0.0). Args: size (int): The minimum size of the struct, in bytes. """ cls._min_size = size def test_pack(self): """Check whether packed objects equals to dump file.""" msg = self.get_raw_object() packed_obj = msg.pack() raw_file = self.get_raw_dump().read() self.assertEqual(packed_obj, raw_file) def test_unpack(self): """Check whether the unpacked dump equals to expected object.""" obj = self.get_raw_object() unpacked = self.get_raw_dump().unpack() self.assertEqual(unpacked, obj) def test_minimum_size(self): """Test struct minimum size.""" if self._min_size is None: raise self.skipTest('minimum size not set.') obj = TestStruct._msg_cls() self.assertEqual(obj.get_size(), self._min_size) python-openflow-1.1.0-alpha2/tests/v0x01/000077500000000000000000000000001275711427400200605ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/tests/v0x01/__init__.py000066400000000000000000000000001275711427400221570ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/tests/v0x01/test_asynchronous/000077500000000000000000000000001275711427400236525ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/tests/v0x01/test_asynchronous/__init__.py000066400000000000000000000000001275711427400257510ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/tests/v0x01/test_asynchronous/test_error_msg.py000066400000000000000000000016311275711427400272630ustar00rootroot00000000000000import unittest from pyof.v0x01.asynchronous import error_msg class TestErrorMsg(unittest.TestCase): """Test the ErrorMsg message""" def setUp(self): """Setup the TestErrorMsg Class instantiating a ErrorMsg message""" self.message = error_msg.ErrorMsg() self.message.header.xid = 1 self.message.type = error_msg.ErrorType.OFPET_BAD_ACTION self.message.code = error_msg.BadActionCode.OFPBAC_EPERM self.message.data = [] def test_size(self): """[Asynchronous/ErrorMsg] - size 12""" self.assertEqual(self.message.get_size(), 12, 'Wrong message size') @unittest.skip('Not yet implemented') def test_pack(self): """[Asynchronous/ErrorMsg] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Asynchronous/ErrorMsg] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_asynchronous/test_flow_removed.py000066400000000000000000000033401275711427400277530ustar00rootroot00000000000000import unittest from pyof.v0x01.asynchronous import flow_removed from pyof.v0x01.common import flow_match class TestFlowRemoved(unittest.TestCase): """Test the FlowRemoved message""" def setUp(self): """Setup the TestFlowremoved Class instantiating""" self.message = flow_removed.FlowRemoved() self.message.header.xid = 1 self.message.match = flow_match.Match() self.message.cookie = 0 self.message.priority = 1 self.message.reason = flow_removed.FlowRemovedReason.OFPRR_IDLE_TIMEOUT self.message.duration_sec = 4 self.message.duration_nsec = 23 self.message.idle_timeout = 9 self.message.packet_count = 10 self.message.byte_count = 4 self.message.match.wildcards = flow_match.FlowWildCards.OFPFW_TP_DST self.message.match.in_port = 80 self.message.match.dl_src = [1, 2, 3, 4, 5, 6] self.message.match.dl_dst = [1, 2, 3, 4, 5, 6] self.message.match.dl_vlan = 1 self.message.match.dl_vlan_pcp = 1 self.message.match.dl_type = 1 self.message.match.nw_tos = 1 self.message.match.nw_proto = 1 self.message.match.nw_src = 10000 self.message.match.nw_dst = 10000 self.message.match.tp_src = 80 self.message.match.tp_dst = 80 def test_size(self): """[Asynchronous/FlowRemoved] - size 88""" self.assertEqual(self.message.get_size(), 88) @unittest.skip('Not yet implemented') def test_pack(self): """[Asynchronous/FlowRemoved] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Asynchronous/FlowRemoved] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_asynchronous/test_packet_in.py000066400000000000000000000017411275711427400272230ustar00rootroot00000000000000"""Packet in message tests.""" import unittest from pyof.v0x01.asynchronous.packet_in import PacketIn, PacketInReason from tests.test_struct import TestStruct class TestPacketIn(TestStruct): """Packet in message tests (also those in :class:`.TestDump`).""" @classmethod def setUpClass(cls): """Configure raw file and its object in parent class (TestDump).""" super().setUpClass() super().set_raw_dump_file('v0x01', 'ofpt_packet_in') super().set_raw_dump_object(PacketIn, xid=1, buffer_id=1, total_len=1, in_port=1, reason=PacketInReason.OFPR_ACTION) # Different from the specification, the minimum size of this class is # 18, not 20. super().set_minimum_size(18) @unittest.skip('Need to recover dump contents.') def test_pack(self): pass @unittest.skip('Need to recover dump contents.') def test_unpack(self): pass python-openflow-1.1.0-alpha2/tests/v0x01/test_asynchronous/test_port_status.py000066400000000000000000000031621275711427400276540ustar00rootroot00000000000000"""Port Status message tests.""" import unittest from pyof.v0x01.asynchronous.port_status import PortReason, PortStatus from pyof.v0x01.common.phy_port import (PhyPort, PortConfig, PortFeatures, PortState) from pyof.v0x01.foundation.base import OFP_MAX_PORT_NAME_LEN from pyof.v0x01.foundation.basic_types import HWAddress from tests.test_struct import TestStruct class TestPortStatus(TestStruct): """Test the Port Status message.""" @classmethod def setUpClass(cls): """Configure raw file and its object in parent class (TestDump).""" super().setUpClass() super().set_raw_dump_file('v0x01', 'ofpt_port_status') super().set_raw_dump_object(_new_portstatus) super().set_minimum_size(64) @unittest.skip('Need to recover dump contents.') def test_pack(self): pass @unittest.skip('Need to recover dump contents.') def test_unpack(self): pass def _new_portstatus(): """Crate new PortStatus and PhyPort instances.""" desc_name = 'X' * OFP_MAX_PORT_NAME_LEN desc = PhyPort(port_no=2, hw_addr=HWAddress('0a:0a:12:12:10:10'), name=desc_name, config=PortConfig.OFPPC_NO_STP, state=PortState.OFPPS_STP_FORWARD, curr=PortFeatures.OFPPF_10GB_FD, advertised=PortFeatures.OFPPF_PAUSE, supported=PortFeatures.OFPPF_AUTONEG, peer=PortFeatures.OFPPF_AUTONEG) return PortStatus(xid=1, reason=PortReason.OFPPR_ADD, desc=desc) python-openflow-1.1.0-alpha2/tests/v0x01/test_common/000077500000000000000000000000001275711427400224075ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/tests/v0x01/test_common/__init__.py000066400000000000000000000000001275711427400245060ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/tests/v0x01/test_common/test_action.py000066400000000000000000000140541275711427400253010ustar00rootroot00000000000000import unittest from pyof.v0x01.common import action from pyof.v0x01.common import phy_port class TestActionHeader(unittest.TestCase): """Test the ActionHeader message""" def setUp(self): self.message = action.ActionHeader() self.message.action_type = action.ActionType.OFPAT_SET_TP_SRC self.message.len = 1 def test_get_size(self): """[Common/ActionHeader] - size 8""" self.assertEqual(self.message.get_size(), 8) @unittest.skip('Not yet implemented') def test_pack(self): """[Common/ActionHeader] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Common/ActionHeader] - unpacking""" # TODO pass class TestActionOutput(unittest.TestCase): def setUp(self): self.message = action.ActionOutput() self.message.port = phy_port.Port.OFPP_CONTROLLER self.message.max_len = 8 def test_get_size(self): """[Common/ActionOutput] - size 8""" self.assertEqual(self.message.get_size(), 8) @unittest.skip('Not yet implemented') def test_pack(self): """[Common/ActionOutput] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Common/ActionOutput] - packing""" # TODO pass class TestActionEnqueue(unittest.TestCase): def setUp(self): self.message = action.ActionEnqueue() self.message.port = phy_port.Port.OFPP_CONTROLLER self.message.queue_id = 4 def test_get_size(self): """[Common/ActionEnqueue] - size 16""" self.assertEqual(self.message.get_size(), 16) @unittest.skip('Not yet implemented') def test_pack(self): """[Common/ActionEnqueue] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Common/ActionEnqueue] - unpacking""" # TODO pass class TestActionVlanVid(unittest.TestCase): def setUp(self): self.message = action.ActionVlanVid() self.message.length = 2 self.message.vlan_vid = 5 def test_get_size(self): """[Common/ActionVlanVid] - size 8""" self.assertEqual(self.message.get_size(), 8) @unittest.skip('Not yet implemented') def test_pack(self): """[Common/ActionVlanVid] - packing""" # TODO @unittest.skip('Not yet implemented') def test_unpack(self): """[Common/ActionVlanVid] - unpacking""" # TODO class TestActionVlanPCP(unittest.TestCase): def setUp(self): self.message = action.ActionVlanPCP() self.message.vlan_pcp = 2 def test_get_size(self): """[Common/ActionVlanPCP] - size 8""" self.assertEqual(self.message.get_size(), 8) @unittest.skip('Not yet implemented') def test_pack(self): """[Common/Actionvlanpcp] - packing""" # TODO @unittest.skip('Not yet implemented') def test_unpack(self): """[Common/ActionVlanVid] - unpacking""" # TODO class TestActionDLAddr(unittest.TestCase): def setUp(self): self.message = action.ActionDLAddr() self.message.dl_addr_type = action.ActionType.OFPAT_SET_DL_SRC self.message.dl_addr = [12, 12, 12, 12, 12, 12] def test_get_size(self): """[Common/ActionDLAddr] - size 16""" self.assertEqual(self.message.get_size(), 16) @unittest.skip('Not yet implemented') def test_pack(self): """[Common/ActionDLAddr] - packing""" # TODO @unittest.skip('Not yet implemented') def test_unpack(self): """[Common/ActionDLAddr] - unpacking""" # TODO class TestActionNWAddr(unittest.TestCase): def setUp(self): self.message = action.ActionNWAddr() self.message.nw_addr_type = action.ActionType.OFPAT_SET_NW_SRC self.message.nw_addr = [12, 12, 12, 12, 12, 12] def test_get_size(self): """[Common/ActionNWAddr] - size 8""" self.assertEqual(self.message.get_size(), 8) @unittest.skip('Not yet implemented') def test_pack(self): """[Common/ActionNWAddr] - packing""" # TODO @unittest.skip('Not yet implemented') def test_unpack(self): """[Common/ActionNWAddr] - unpacking""" # TODO class TestActionNWTos(unittest.TestCase): def setUp(self): self.message = action.ActionNWTos() self.message.nw_tos_type = action.ActionType.OFPAT_SET_NW_SRC self.message.nw_tos = 123456 def test_get_size(self): """[Common/ActionNWTos] - size 8""" self.assertEqual(self.message.get_size(), 8) @unittest.skip('Not yet implemented') def test_pack(self): """[Common/ActionNWTos] - packing""" # TODO @unittest.skip('Not yet implemented') def test_unpack(self): """[Common/ActionNWTos] - unpacking""" # TODO class TestActionTPPort(unittest.TestCase): def setUp(self): self.message = action.ActionTPPort() self.message.tp_port_type = action.ActionType.OFPAT_SET_TP_SRC self.message.tp_port = 8888 def test_get_size(self): """[Common/ActionTPPort] - size 8""" self.assertEqual(self.message.get_size(), 8) @unittest.skip('Not yet implemented') def test_pack(self): """[Common/ActionTPPort] - packing""" # TODO @unittest.skip('Not yet implemented') def test_unpack(self): """[Common/ActionTPPort] - unpacking""" # TODO class TestActionVendorHeader(unittest.TestCase): def setUp(self): self.message = action.ActionVendorHeader() self.message.length = 16 self.message.vendor = 1 def test_get_size(self): """[Common/ActionVendorHeader] - size 8""" self.assertEqual(self.message.get_size(), 8) @unittest.skip('Not yet implemented') def test_pack(self): """[Common/ActionVendorHeader] - packing""" # TODO @unittest.skip('Not yet implemented') def test_unpack(self): """[Common/ActionVendorHeader] - unpacking""" # TODO python-openflow-1.1.0-alpha2/tests/v0x01/test_common/test_flow_match.py000066400000000000000000000020641275711427400261450ustar00rootroot00000000000000import unittest from pyof.v0x01.common import flow_match class TestMatch(unittest.TestCase): def setUp(self): self.message = flow_match.Match() self.message.wildcards = flow_match.FlowWildCards.OFPFW_IN_PORT self.message.in_port = 22 self.message.dl_src = [192, 168, 0, 2] self.message.dl_dst = [129, 168, 0, 3] self.message.dl_vlan = 1 self.message.dl_vlan_pcp = 1 self.message.dl_type = 1 self.message.nw_tos = 1 self.message.nw_proto = 1 self.message.nw_src = 10000 self.message.nw_dst = 10000 self.message.tp_src = 22 self.message.tp_dst = 22 def test_get_size(self): """[Common/FlowMatch] - size 40""" self.assertEqual(self.message.get_size(), 40) @unittest.skip('Not yet implemented') def test_pack(self): """[Common/FlowMatch] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Common/FlowMatch] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_common/test_header.py000066400000000000000000000026561275711427400252610ustar00rootroot00000000000000import unittest import os from pyof.v0x01.common import header as of_header class TestHeader(unittest.TestCase): """Test the message Header""" def setUp(self): """Setup the TestHeader Class instantiating a HELLO header""" self.message = of_header.Header() self.message.message_type = of_header.Type.OFPT_HELLO self.message.xid = 1 self.message.length = 0 def test_size(self): """[Common/Header] - size 8""" self.assertEqual(self.message.get_size(), 8) @unittest.expectedFailure def test_pack_empty(self): """[Common/Header] - packing empty header""" self.assertRaises(TypeError, of_header.Header().pack()) def test_pack(self): """[Common/Header] - packing Hello""" packed_header = b'\x01\x00\x00\x00\x00\x00\x00\x01' self.assertEqual(self.message.pack(), packed_header) def test_unpack(self): """[Common/Header] - unpacking Hello""" filename = os.path.join(os.path.dirname(os.path.realpath('__file__')), 'raw/v0x01/ofpt_hello.dat') f = open(filename, 'rb') self.message.unpack(f.read(8)) self.assertEqual(self.message.length, 8) self.assertEqual(self.message.xid, 1) self.assertEqual(self.message.message_type, of_header.Type.OFPT_HELLO) self.assertEqual(self.message.version, 1) f.close() python-openflow-1.1.0-alpha2/tests/v0x01/test_common/test_phy_port.py000066400000000000000000000022051275711427400256630ustar00rootroot00000000000000import unittest from pyof.v0x01.common import phy_port from pyof.v0x01.foundation import base class TestPhyPort(unittest.TestCase): def setUp(self): self.message = phy_port.PhyPort() self.message.port_no = 2 self.message.hw_addr = '1a:2b:3c:4d:5e:6f' self.message.name = bytes('X' * base.OFP_MAX_PORT_NAME_LEN, 'utf-8') self.message.config = phy_port.PortConfig.OFPPC_NO_STP self.message.state = phy_port.PortState.OFPPS_STP_FORWARD self.message.curr = phy_port.PortFeatures.OFPPF_10GB_FD self.message.advertised = phy_port.PortFeatures.OFPPF_PAUSE self.message.supported = phy_port.PortFeatures.OFPPF_AUTONEG self.message.peer = phy_port.PortFeatures.OFPPF_AUTONEG def test_get_size(self): """[Common/PhyPort] - size 48""" self.assertEqual(self.message.get_size(), 48) @unittest.skip('Not yet implemented') def test_pack(self): """[Common/PhyPort] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Common/PhyPort] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_common/test_queue.py000066400000000000000000000034711275711427400251510ustar00rootroot00000000000000import unittest from pyof.v0x01.common import queue class TestQueuePropHeader(unittest.TestCase): def setUp(self): self.message = queue.QueuePropHeader() self.message.property = queue.QueueProperties.OFPQT_MIN_RATE self.message.len = 12 def test_get_size(self): """[Common/QueuePropHeader] - size 8""" self.assertEqual(self.message.get_size(), 8) @unittest.skip('Not yet implemented') def test_pack(self): """[Common/QueuePropHeader] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Common/QueuePropHeader] - unpacking""" # TODO pass class TestPacketQueue(unittest.TestCase): def setUp(self): self.message = queue.PacketQueue() self.message.queue_id = 1 self.message.length = 8 def test_get_size(self): """[Common/PacketQueue] - size 8""" self.assertEqual(self.message.get_size(), 8) @unittest.skip('Not yet implemented') def test_pack(self): """[Common/PacketQueue] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Common/PacketQueue] - unpacking""" # TODO pass class TestQueuePropMinRate(unittest.TestCase): def setUp(self): self.message = queue.QueuePropMinRate() self.message.rate = 1000 def test_get_size(self): """[Common/PropMinRate] - size 16""" self.assertEqual(self.message.get_size(), 16) @unittest.skip('Not yet implemented') def test_pack(self): """[Common/PropMinRate] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Common/PropMinRate] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/000077500000000000000000000000001275711427400246065ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/__init__.py000066400000000000000000000000001275711427400267050ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_aggregate_stats_reply.py000066400000000000000000000014221275711427400325750ustar00rootroot00000000000000import unittest from pyof.v0x01.controller2switch.common import AggregateStatsReply class TestAggregateStatsReply(unittest.TestCase): def setUp(self): self.message = AggregateStatsReply() self.message.packet_count = 5 self.message.byte_count = 1 self.message.flow_count = 8 def test_get_size(self): """[Controller2Switch/AggregateStatsReply] - size 24""" self.assertEqual(self.message.get_size(), 24) @unittest.skip('Not yet implemented') def test_pack(self): """[Controller2Switch/AggregateStatsReply] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Controller2Switch/AggregateStatsReply] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_aggregate_stats_request.py000066400000000000000000000027261275711427400331420ustar00rootroot00000000000000import unittest from pyof.v0x01.common import flow_match from pyof.v0x01.common import phy_port from pyof.v0x01.controller2switch.common import AggregateStatsRequest class TestAggregateStatsRequest(unittest.TestCase): def setUp(self): self.message = AggregateStatsRequest() self.message.match = flow_match.Match() self.message.table_id = 1 self.message.out_port = phy_port.Port.OFPP_NONE self.message.match.wildcards = flow_match.FlowWildCards.OFPFW_TP_DST self.message.match.in_port = 80 self.message.match.dl_src = [1, 2, 3, 4, 5, 6] self.message.match.dl_dst = [1, 2, 3, 4, 5, 6] self.message.match.dl_vlan = 1 self.message.match.dl_vlan_pcp = 1 self.message.match.dl_type = 1 self.message.match.nw_tos = 1 self.message.match.nw_proto = 1 self.message.match.nw_src = 10000 self.message.match.nw_dst = 10000 self.message.match.tp_src = 80 self.message.match.tp_dst = 80 def test_get_size(self): """[Controller2Switch/AggregateStatsRequest] - size 44""" self.assertEqual(self.message.get_size(), 44) @unittest.skip('Not yet implemented') def test_pack(self): """[Controller2Switch/AggregateStatsRequest] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Controller2Switch/AggregateStatsRequest] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_barrier_reply.py000066400000000000000000000010621275711427400310570ustar00rootroot00000000000000"""Barrier reply message tests.""" from pyof.v0x01.controller2switch.barrier_reply import BarrierReply from tests.test_struct import TestStruct class TestBarrierReply(TestStruct): """Barrier reply message tests (also those in :class:`.TestDump`).""" @classmethod def setUpClass(cls): """Configure raw file and its object in parent class (TestDump).""" super().setUpClass() super().set_raw_dump_file('v0x01', 'ofpt_barrier_reply') super().set_raw_dump_object(BarrierReply, xid=5) super().set_minimum_size(8) python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_barrier_request.py000066400000000000000000000010761275711427400314210ustar00rootroot00000000000000"""Barrier request message tests.""" from pyof.v0x01.controller2switch.barrier_request import BarrierRequest from tests.test_struct import TestStruct class TestBarrierRequest(TestStruct): """Barrier reply message tests (also those in :class:`.TestDump`).""" @classmethod def setUpClass(cls): """Configure raw file and its object in parent class (TestDump).""" super().setUpClass() super().set_raw_dump_file('v0x01', 'ofpt_barrier_request') super().set_raw_dump_object(BarrierRequest, xid=5) super().set_minimum_size(8) python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_desc_stats.py000066400000000000000000000016071275711427400303570ustar00rootroot00000000000000import unittest from pyof.v0x01.controller2switch.common import DescStats from pyof.v0x01.foundation import base class TestDescStats(unittest.TestCase): def setUp(self): content = bytes('A' * base.DESC_STR_LEN, 'utf-8') self.message = DescStats() self.message.mfr_desc = content self.message.hw_desc = content self.message.sw_desc = content self.message.serial_num = content self.message.dp_desc = content def test_get_size(self): """[Controller2Switch/DescStats] - size 1056""" self.assertEqual(self.message.get_size(), 1056) @unittest.skip('Not yet implemented') def test_pack(self): """[Controller2Switch/DescStats] - packing""" # TODO @unittest.skip('Not yet implemented') def test_unpack(self): """[Controller2Switch/DescStats] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_features_reply.py000066400000000000000000000035261275711427400312560ustar00rootroot00000000000000"""Echo request message tests.""" from pyof.v0x01.common.phy_port import PhyPort, PortConfig, PortState from pyof.v0x01.controller2switch.features_reply import FeaturesReply from pyof.v0x01.foundation.basic_types import HWAddress from tests.test_struct import TestStruct class TestFeaturesReply(TestStruct): """Feature reply message tests (also those in :class:`.TestDump`).""" @classmethod def setUpClass(cls): """Configure raw file and its object in parent class (TestDump).""" super().setUpClass() super().set_raw_dump_file('v0x01', 'ofpt_features_reply') kwargs = _get_kwargs() super().set_raw_dump_object(FeaturesReply, **kwargs) super().set_minimum_size(32) def _get_kwargs(): return {'xid': 2, 'datapath_id': 1, 'n_buffers': 256, 'n_tables': 254, 'capabilities': 0x000000c7, 'actions': 4095, 'ports': _get_ports()} def _get_ports(): return [ PhyPort(port_no=65534, hw_addr=HWAddress('0e:d3:98:a5:30:47'), name='s1', config=PortConfig.OFPC_PORT_DOWN, state=PortState.OFPPS_LINK_DOWN, curr=0, advertised=0, supported=0, peer=0), PhyPort(port_no=1, hw_addr=HWAddress('0a:54:cf:fc:4e:6d'), name='s1-eth1', config=0, state=PortState.OFPPS_STP_LISTEN, curr=0x000000c0, advertised=0, supported=0, peer=0), PhyPort(port_no=2, hw_addr=HWAddress('f6:b6:ab:cc:f8:4f'), name='s1-eth2', config=0, state=PortState.OFPPS_STP_LISTEN, curr=0x000000c0, advertised=0, supported=0, peer=0) ] python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_features_request.py000066400000000000000000000011051275711427400316020ustar00rootroot00000000000000"""Feature request message tests.""" from pyof.v0x01.controller2switch.features_request import FeaturesRequest from tests.test_struct import TestStruct class TestFeaturesRequest(TestStruct): """Feature request message tests (also those in :class:`.TestDump`).""" @classmethod def setUpClass(cls): """Configure raw file and its object in parent class (TestDump).""" super().setUpClass() super().set_raw_dump_file('v0x01', 'ofpt_features_request') super().set_raw_dump_object(FeaturesRequest, xid=3) super().set_minimum_size(8) python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_flow_mod.py000066400000000000000000000043511275711427400300300ustar00rootroot00000000000000"""Flow modification (add/delete) message tests.""" import unittest from pyof.v0x01.common.flow_match import Match from pyof.v0x01.common.phy_port import Port from pyof.v0x01.controller2switch.flow_mod import FlowMod, FlowModCommand from tests.test_struct import TestStruct class TestFlowAdd(TestStruct): """Flow addition message tests (also those in :class:`.TestDump`).""" @classmethod def setUpClass(cls): """Configure raw file and its object in parent class (TestDump).""" super().setUpClass() super().set_raw_dump_file('v0x01', 'ofpt_flow_add') kwargs = _get_flowmod_kwargs(FlowModCommand.OFPFC_ADD) super().set_raw_dump_object(FlowMod, **kwargs) super().set_minimum_size(72) @unittest.skip('Need to recover dump contents.') def test_pack(self): pass @unittest.skip('Need to recover dump contents.') def test_unpack(self): pass class TestFlowDelete(TestStruct): """Flow deletion message tests (also those in :class:`.TestDump`).""" @classmethod def setUpClass(cls): """Configure raw file and its object in parent class (TestDump).""" super().setUpClass() super().set_raw_dump_file('v0x01', 'ofpt_flow_delete') kwargs = _get_flowmod_kwargs(FlowModCommand.OFPFC_DELETE) super().set_raw_dump_object(FlowMod, **kwargs) # No need to test minimum size again. def _get_flowmod_kwargs(command): """Return parameters for FlowMod object.""" return {'xid': 4, 'command': command, 'match': _get_match(), 'cookie': 0, 'idle_timeout': 0, 'hard_timeout': 0, 'priority': 32768, 'buffer_id': 4294967295, 'out_port': Port.OFPP_NONE, 'flags': 0} def _get_match(): """Return a Match object.""" return Match(wildcards=0x000000000010001f, in_port=0, dl_src='00:00:00:00:00:00', dl_dst='00:00:00:00:00:00', dl_vlan=0, dl_vlan_pcp=0, dl_type=0, nw_tos=0, nw_proto=0, nw_src=0, nw_dst=0, tp_src=0, tp_dst=0) python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_flow_stats.py000066400000000000000000000030631275711427400304060ustar00rootroot00000000000000import unittest from pyof.v0x01.common import flow_match from pyof.v0x01.controller2switch.common import FlowStats class TestFlowStats(unittest.TestCase): def setUp(self): self.message = FlowStats() self.message.length = 160 self.message.table_id = 1 self.message.match = flow_match.Match() self.message.duration_sec = 60 self.message.duration_nsec = 10000 self.message.priority = 1 self.message.idle_timeout = 300 self.message.hard_timeout = 6000 self.message.cookie = 1 self.message.packet_count = 1 self.message.byte_count = 1 self.message.match.in_port = 80 self.message.match.dl_src = [1, 2, 3, 4, 5, 6] self.message.match.dl_dst = [1, 2, 3, 4, 5, 6] self.message.match.dl_vlan = 1 self.message.match.dl_vlan_pcp = 1 self.message.match.dl_type = 1 self.message.match.nw_tos = 1 self.message.match.nw_proto = 1 self.message.match.nw_src = 10000 self.message.match.nw_dst = 10000 self.message.match.tp_src = 80 self.message.match.tp_dst = 80 def test_get_size(self): """[Controller2Switch/FlowStats] - size 88""" self.assertEqual(self.message.get_size(), 88) @unittest.skip('Not yet implemented') def test_pack(self): """[Controller2Switch/FlowStats] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Controller2Switch/FlowStats] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_flow_stats_request.py000066400000000000000000000024571275711427400321640ustar00rootroot00000000000000import unittest from pyof.v0x01.common import flow_match from pyof.v0x01.controller2switch.common import FlowStatsRequest class TestFlowStatsRequest(unittest.TestCase): def setUp(self): self.message = FlowStatsRequest() self.message.match = flow_match.Match() self.message.table_id = 1 self.message.out_port = 80 self.message.match.in_port = 80 self.message.match.dl_src = [1, 2, 3, 4, 5, 6] self.message.match.dl_dst = [1, 2, 3, 4, 5, 6] self.message.match.dl_vlan = 1 self.message.match.dl_vlan_pcp = 1 self.message.match.dl_type = 1 self.message.match.nw_tos = 1 self.message.match.nw_proto = 1 self.message.match.nw_src = 10000 self.message.match.nw_dst = 10000 self.message.match.tp_src = 80 self.message.match.tp_dst = 80 def test_get_size(self): """[Controller2Switch/FlowStatsRequest] - size 44""" self.assertEqual(self.message.get_size(), 44) @unittest.skip('Not yet implemented') def test_pack(self): """[Controller2Switch/FlowStatsRequest] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Controller2Switch/FlowStatsRequest] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_get_config_reply.py000066400000000000000000000015211275711427400315350ustar00rootroot00000000000000import unittest from pyof.v0x01.controller2switch import flow_mod from pyof.v0x01.controller2switch import get_config_reply class TestGetConfigReply(unittest.TestCase): def setUp(self): self.message = get_config_reply.GetConfigReply() self.message.header.xid = 1 self.message.flags = flow_mod.FlowModFlags.OFPFF_EMERG self.message.miss_send_len = 1024 def test_get_size(self): """[Controller2Switch/GetConfigReply] - size 12""" self.assertEqual(self.message.get_size(), 12) @unittest.skip('Not yet implemented') def test_pack(self): """[Controller2Switch/GetConfigReply] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Controller2Switch/GetConfigReply] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_get_config_request.py000066400000000000000000000012371275711427400320760ustar00rootroot00000000000000import unittest from pyof.v0x01.controller2switch import get_config_request class TestGetConfigRequest(unittest.TestCase): def setUp(self): self.message = get_config_request.GetConfigRequest(1) def test_get_size(self): """[Controller2Switch/GetConfigRequest] - size 8""" self.assertEqual(self.message.get_size(), 8) @unittest.skip('Not yet implemented') def test_pack(self): """[Controller2Switch/GetConfigRequest] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Controller2Switch/GetConfigRequest] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_packet_out.py000066400000000000000000000047421275711427400303640ustar00rootroot00000000000000"""Packet out message tests.""" import unittest from pyof.v0x01.common.phy_port import Port from pyof.v0x01.controller2switch.packet_out import PacketOut from pyof.v0x01.foundation.exceptions import ValidationError from tests.test_struct import TestStruct class TestPacketOut(TestStruct): """Packet out message tests (also those in :class:`.TestDump`). Attributes: message (PacketOut): The message configured in :meth:`setUpClass`. """ @classmethod def setUpClass(cls): """Configure raw file and its object in parent class (TestDump).""" super().setUpClass() super().set_raw_dump_file('v0x01', 'ofpt_packet_out') super().set_raw_dump_object(PacketOut, xid=80, buffer_id=5, in_port=Port.OFPP_NONE, actions_len=0) super().set_minimum_size(16) def setUp(self): """Run before every test.""" self.message = self.get_raw_object() @unittest.skip('Need to recover dump contents.') def test_pack(self): pass @unittest.skip('Need to recover dump contents.') def test_unpack(self): pass def test_valid_virtual_in_ports(self): """Valid virtual ports as defined in 1.0.1 spec.""" valid = (Port.OFPP_LOCAL, Port.OFPP_CONTROLLER, Port.OFPP_NONE) for in_port in valid: self.message.in_port = in_port self.assertTrue(self.message.is_valid()) def test_invalid_virtual_in_ports(self): """Invalid virtual ports as defined in 1.0.1 spec.""" invalid = (Port.OFPP_IN_PORT, Port.OFPP_TABLE, Port.OFPP_NORMAL, Port.OFPP_FLOOD, Port.OFPP_ALL) for in_port in invalid: self.message.in_port = in_port self.assertFalse(self.message.is_valid()) self.assertRaises(ValidationError, self.message.validate) def test_valid_physical_in_ports(self): """Physical port limits from 1.0.0 spec.""" max_valid = int(Port.OFPP_MAX.value) - 1 for in_port in (1, max_valid): self.message.in_port = in_port self.assertTrue(self.message.is_valid()) def test_invalid_physical_in_port(self): """Physical port limits from 1.0.0 spec.""" max_valid = int(Port.OFPP_MAX.value) - 1 for in_port in (-1, 0, max_valid + 1, max_valid + 2): self.message.in_port = in_port self.assertFalse(self.message.is_valid()) self.assertRaises(ValidationError, self.message.validate) python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_port_mod.py000066400000000000000000000015031275711427400300410ustar00rootroot00000000000000import unittest from pyof.v0x01.controller2switch import port_mod class TestPortMod(unittest.TestCase): def setUp(self): self.message = port_mod.PortMod() self.message.header.xid = 1 self.message.port_no = 80 self.message.hw_addr = 'aa:bb:cc:00:33:9f' self.message.config = 1 << 2 self.message.mask = 1 << 1 self.message.advertise = 1 def test_get_size(self): """[Controller2Switch/PortMod] - size 32""" self.assertEqual(self.message.get_size(), 32) @unittest.skip('Not yet implemented') def test_pack(self): """[Controller2Switch/PortMod] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Controller2Switch/PortMod] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_port_stats.py000066400000000000000000000020761275711427400304260ustar00rootroot00000000000000import unittest from pyof.v0x01.controller2switch.common import PortStats class TestPortStats(unittest.TestCase): def setUp(self): self.message = PortStats() self.message.port_no = 80 self.message.rx_packets = 5 self.message.tx_packets = 10 self.message.rx_bytes = 200 self.message.tx_bytes = 400 self.message.rx_dropped = 0 self.message.tx_dropped = 0 self.message.rx_errors = 0 self.message.tx_errors = 0 self.message.rx_frame_err = 0 self.message.rx_over_err = 0 self.message.rx_crc_err = 0 self.message.collisions = 0 def test_get_size(self): """[Controller2Switch/PortStats] - size 104""" self.assertEqual(self.message.get_size(), 104) @unittest.skip('Not yet implemented') def test_pack(self): """[Controller2Switch/PortStats] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Controller2Switch/PortStats] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_port_stats_request.py000066400000000000000000000012621275711427400321720ustar00rootroot00000000000000import unittest from pyof.v0x01.controller2switch.common import PortStatsRequest class TestPortStatsRequest(unittest.TestCase): def setUp(self): self.message = PortStatsRequest() self.message.port_no = 80 def test_get_size(self): """[Controller2Switch/PortStatsRequest] - size 8""" self.assertEqual(self.message.get_size(), 8) @unittest.skip('Not yet implemented') def test_pack(self): """[Controller2Switch/PortStatsRequest] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Controller2Switch/PortStatsRequest] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_queue_get_config_reply.py000066400000000000000000000021641275711427400327450ustar00rootroot00000000000000import unittest from pyof.v0x01.controller2switch import queue_get_config_reply from pyof.v0x01.common import queue class TestQueueGetConfigReply(unittest.TestCase): def setUp(self): propertie01 = queue.QueuePropHeader() propertie01.property = queue.QueueProperties.OFPQT_MIN_RATE propertie01.len = 12 packet_queue = queue.PacketQueue() packet_queue.queue_id = 1 packet_queue.length = 8 packet_queue.properties = [propertie01] self.message = queue_get_config_reply.QueueGetConfigReply() self.message.header.xid = 1 self.message.port = 80 self.message.queue = packet_queue def test_get_size(self): """[Controller2Switch/QueueGetConfigReply] - size 16""" self.assertEqual(self.message.get_size(), 16) @unittest.skip('Not yet implemented') def test_pack(self): """[Controller2Switch/QueueGetConfigReply] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Controller2Switch/QueueGetConfigReply] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_queue_get_config_request.py000066400000000000000000000014101275711427400332730ustar00rootroot00000000000000import unittest from pyof.v0x01.controller2switch import queue_get_config_request class TestQueueGetConfigRequest(unittest.TestCase): def setUp(self): self.message = queue_get_config_request.QueueGetConfigRequest() self.message.header.xid = 1 self.message.port = 80 def test_get_size(self): """[Controller2Switch/QueueGetConfigRequest] - size 12""" self.assertEqual(self.message.get_size(), 12) @unittest.skip('Not yet implemented') def test_pack(self): """[Controller2Switch/QueueGetConfigRequest] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Controller2Switch/QueueGetConfigRequest] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_queue_stats.py000066400000000000000000000014331275711427400305620ustar00rootroot00000000000000import unittest from pyof.v0x01.controller2switch.common import QueueStats class TestQueueStats(unittest.TestCase): def setUp(self): self.message = QueueStats() self.message.port_no = 80 self.message.queue_id = 5 self.message.tx_bytes = 1 self.message.tx_packets = 3 self.message.tx_errors = 2 def test_get_size(self): """[Controller2Switch/QueueStats] - size 32""" self.assertEqual(self.message.get_size(), 32) @unittest.skip('Not yet implemented') def test_pack(self): """[Controller2Switch/QueueStats] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Controller2Switch/QueueStats] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_queue_stats_request.py000066400000000000000000000013321275711427400323300ustar00rootroot00000000000000import unittest from pyof.v0x01.controller2switch.common import QueueStatsRequest class TestQueueStatsRequest(unittest.TestCase): def setUp(self): self.message = QueueStatsRequest() self.message.port_no = 80 self.message.queue_id = 5 def test_get_size(self): """[Controller2Switch/QueueStatsRequest] - size 8""" self.assertEqual(self.message.get_size(), 8) @unittest.skip('Not yet implemented') def test_pack(self): """[Controller2Switch/QueueStatsRequest] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Controller2Switch/QueueStatsRequest] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_set_config.py000066400000000000000000000012711275711427400303400ustar00rootroot00000000000000"""Set Config message tests.""" from pyof.v0x01.controller2switch.common import ConfigFlags from pyof.v0x01.controller2switch.set_config import SetConfig from tests.test_struct import TestStruct class TestSetConfig(TestStruct): """Test the Set Config message.""" @classmethod def setUpClass(cls): """Configure raw file and its object in parent class (TestDump).""" super().setUpClass() super().set_raw_dump_file('v0x01', 'ofpt_set_config') super().set_raw_dump_object(SetConfig, xid=3, flags=ConfigFlags.OFPC_FRAG_NORMAL, miss_send_len=128) super().set_minimum_size(12) python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_stats_reply.py000066400000000000000000000015041275711427400305700ustar00rootroot00000000000000import unittest from pyof.v0x01.controller2switch import common from pyof.v0x01.controller2switch import stats_reply class TestStatsReply(unittest.TestCase): def setUp(self): self.message = stats_reply.StatsReply() self.message.header.xid = 1 self.message.type = common.StatsTypes.OFPST_FLOW self.message.flags = 0x0001 self.message.body = [] def test_get_size(self): """[Controller2Switch/StatsReply] - size 12""" self.assertEqual(self.message.get_size(), 12) @unittest.skip('Not yet implemented') def test_pack(self): """[Controller2Switch/StatsReply] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Controller2Switch/StatsReply] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_stats_request.py000066400000000000000000000015151275711427400311270ustar00rootroot00000000000000import unittest from pyof.v0x01.controller2switch import common from pyof.v0x01.controller2switch import stats_request class TestStatsRequest(unittest.TestCase): def setUp(self): self.message = stats_request.StatsRequest() self.message.header.xid = 1 self.message.type = common.StatsTypes.OFPST_FLOW self.message.flags = 1 self.message.body = [] def test_get_size(self): """[Controller2Switch/StatsRequest] - size 12""" self.assertEqual(self.message.get_size(), 12) @unittest.skip('Not yet implemented') def test_pack(self): """[Controller2Switch/StatsRequest] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Controller2Switch/StatsRequest] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_controller2switch/test_table_stats.py000066400000000000000000000020171275711427400305240ustar00rootroot00000000000000import unittest from pyof.v0x01.common import flow_match from pyof.v0x01.controller2switch.common import TableStats from pyof.v0x01.foundation import base class TestTableStats(unittest.TestCase): def setUp(self): self.message = TableStats() self.message.table_id = 1 self.message.name = bytes('X' * base.OFP_MAX_TABLE_NAME_LEN, 'utf-8') self.message.wildcards = flow_match.FlowWildCards.OFPFW_TP_DST self.message.max_entries = 1 self.message.active_count = 10 self.message.count_lookup = 10 self.message.count_matched = 0 def test_get_size(self): """[Controller2Switch/TableStats] - size 64""" self.assertEqual(self.message.get_size(), 64) @unittest.skip('Not yet implemented') def test_pack(self): """[Controller2Switch/TableStats] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Controller2Switch/TableStats] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x01/test_foundation/000077500000000000000000000000001275711427400232655ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/tests/v0x01/test_foundation/__init__.py000066400000000000000000000000001275711427400253640ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/tests/v0x01/test_foundation/test_base.py000066400000000000000000000025711275711427400256150ustar00rootroot00000000000000import unittest from pyof.v0x01.foundation import base from pyof.v0x01.foundation import basic_types class TestGenericStruct(unittest.TestCase): def setUp(self): class AttributeA(base.GenericStruct): a1 = basic_types.UBInt8(1) a2 = basic_types.UBInt16(2) class AttributeC(base.GenericStruct): c1 = basic_types.UBInt32(3) c2 = basic_types.UBInt64(4) class AttributeB(base.GenericStruct): c = AttributeC() class MyMessage(base.GenericMessage): a = AttributeA() b = AttributeB() i = basic_types.UBInt32(5) def __init__(self): super().__init__(None) self.MyMessage = MyMessage def test_basic_attributes(self): """[Foundation/Base/GenericStruct] - Attributes Creation""" message1 = self.MyMessage() message2 = self.MyMessage() self.assertIsNot(message1, message2) self.assertIsNot(message1.i, message2.i) self.assertIsNot(message1.a, message2.a) self.assertIsNot(message1.b, message2.b) self.assertIsNot(message1.a.a1, message2.a.a1) self.assertIsNot(message1.a.a2, message2.a.a2) self.assertIsNot(message1.b.c, message2.b.c) self.assertIsNot(message1.b.c.c1, message2.b.c.c1) self.assertIsNot(message1.b.c.c2, message2.b.c.c2) python-openflow-1.1.0-alpha2/tests/v0x01/test_foundation/test_basic_types.py000066400000000000000000000061341275711427400272070ustar00rootroot00000000000000import unittest from pyof.v0x01.foundation import basic_types class TestUBInt8(unittest.TestCase): def setUp(self): self.ubint8 = basic_types.UBInt8() def test_get_size(self): """[Foundation/BasicTypes/UBInt8] - size 1""" self.assertEqual(self.ubint8.get_size(), 1) @unittest.skip('Not yet implemented') def test_pack(self): """[Foundation/BasicTypes/UBInt8] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Foundation/BasicTypes/UBInt8] - unpacking""" # TODO pass class TestUBInt16(unittest.TestCase): def setUp(self): self.ubint16 = basic_types.UBInt16() def test_get_size(self): """[Foundation/BasicTypes/UBInt16] - size 2""" self.assertEqual(self.ubint16.get_size(), 2) @unittest.skip('Not yet implemented') def test_pack(self): """[Foundation/BasicTypes/UBInt16] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Foundation/BasicTypes/UBInt16] - unpacking""" # TODO pass class TestUBInt32(unittest.TestCase): def setUp(self): self.ubint32 = basic_types.UBInt32() def test_get_size(self): """[Foundation/BasicTypes/UBInt32] - size 4""" self.assertEqual(self.ubint32.get_size(), 4) @unittest.skip('Not yet implemented') def test_pack(self): """[Foundation/BasicTypes/UBInt32] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Foundation/BasicTypes/UBInt32] - unpacking""" # TODO pass class TestChar(unittest.TestCase): def setUp(self): self.char1 = basic_types.Char('foo', length=3) self.char2 = basic_types.Char('foo', length=5) def test_get_size(self): """[Foundation/BasicTypes/Char] - get_size""" self.assertEqual(self.char1.get_size(), 3) self.assertEqual(self.char2.get_size(), 5) def test_pack(self): """[Foundation/BasicTypes/Char] - packing""" self.assertEqual(self.char1.pack(), b'fo\x00') self.assertEqual(self.char2.pack(), b'foo\x00\x00') def test_unpack(self): """[Foundation/BasicTypes/Char] - unpacking""" char1 = basic_types.Char(length=3) char2 = basic_types.Char(length=5) char1.unpack(b'fo\x00') char2.unpack(b'foo\x00\x00') self.assertEqual(char1.value, 'fo') self.assertEqual(char2.value, 'foo') class TestHWaddress(unittest.TestCase): def test_unpack_packed(self): mac = '0a:d3:98:a5:30:47' hw_addr = basic_types.HWAddress(mac) packed = hw_addr.pack() unpacked = basic_types.HWAddress() unpacked.unpack(packed) self.assertEqual(mac, unpacked.value) def test_default_value(self): mac = '00:00:00:00:00:00' hw_addr = basic_types.HWAddress() packed = hw_addr.pack() unpacked = basic_types.HWAddress() unpacked.unpack(packed) self.assertEqual(mac, unpacked.value) python-openflow-1.1.0-alpha2/tests/v0x01/test_symmetric/000077500000000000000000000000001275711427400231335ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/tests/v0x01/test_symmetric/__init__.py000066400000000000000000000000001275711427400252320ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/tests/v0x01/test_symmetric/test_echo_reply.py000066400000000000000000000010251275711427400266730ustar00rootroot00000000000000"""Echo reply message tests.""" from pyof.v0x01.symmetric.echo_reply import EchoReply from tests.test_struct import TestStruct class TestEchoReply(TestStruct): """Echo reply message tests (also those in :class:`.TestDump`).""" @classmethod def setUpClass(cls): """Configure raw file and its object in parent class (TestDump).""" super().setUpClass() super().set_raw_dump_file('v0x01', 'ofpt_echo_reply') super().set_raw_dump_object(EchoReply, xid=0) super().set_minimum_size(8) python-openflow-1.1.0-alpha2/tests/v0x01/test_symmetric/test_echo_request.py000066400000000000000000000010431275711427400272300ustar00rootroot00000000000000"""Echo request message tests.""" from pyof.v0x01.symmetric.echo_request import EchoRequest from tests.test_struct import TestStruct class TestEchoRequest(TestStruct): """Echo request message tests (also those in :class:`.TestDump`).""" @classmethod def setUpClass(cls): """Configure raw file and its object in parent class (TestDump).""" super().setUpClass() super().set_raw_dump_file('v0x01', 'ofpt_echo_request') super().set_raw_dump_object(EchoRequest, xid=0) super().set_minimum_size(8) python-openflow-1.1.0-alpha2/tests/v0x01/test_symmetric/test_hello.py000066400000000000000000000007651275711427400256570ustar00rootroot00000000000000"""Hello message tests.""" from pyof.v0x01.symmetric.hello import Hello from tests.test_struct import TestStruct class TestHello(TestStruct): """Hello message tests (also those in :class:`.TestDump`).""" @classmethod def setUpClass(cls): """Configure raw file and its object in parent class (TestDump).""" super().setUpClass() super().set_raw_dump_file('v0x01', 'ofpt_hello') super().set_raw_dump_object(Hello, xid=1) super().set_minimum_size(8) python-openflow-1.1.0-alpha2/tests/v0x01/test_symmetric/test_vendor_header.py000066400000000000000000000011611275711427400273500ustar00rootroot00000000000000import unittest from pyof.v0x01.symmetric import vendor_header class TestVendorHeader(unittest.TestCase): def setUp(self): self.message = vendor_header.VendorHeader(xid=4, vendor=1) def test_get_size(self): """[Symmetric/VendorHeader] - size 12""" self.assertEqual(self.message.get_size(), 12) @unittest.skip('Not yet implemented') def test_pack(self): """[Symmetric/VendorHeader] - packing""" # TODO pass @unittest.skip('Not yet implemented') def test_unpack(self): """[Symmetric/VendorHeader] - unpacking""" # TODO pass python-openflow-1.1.0-alpha2/tests/v0x02/000077500000000000000000000000001275711427400200615ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/tests/v0x02/test_common/000077500000000000000000000000001275711427400224105ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/tests/v0x02/test_common/__init__.py000066400000000000000000000000001275711427400245070ustar00rootroot00000000000000python-openflow-1.1.0-alpha2/tests/v0x02/test_common/test_flow_instruction.py000066400000000000000000000034621275711427400274360ustar00rootroot00000000000000import unittest from pyof.v0x02.common import flow_instruction class TestOFPInstructionGoToTable(unittest.TestCase): def test_get_size(self): message = flow_instruction.OFPInstructionGoToTable( type=flow_instruction.OFPInstructionsType.OFPIT_GOTO_TABLE, len=8, table_id=1, pad=[0, 0, 0]) self.assertEqual(message.get_size(), 8) def test_pack(self): message = flow_instruction.OFPInstructionGoToTable( type=flow_instruction.OFPInstructionsType.OFPIT_GOTO_TABLE, len=8, table_id=1, pad=[0, 0, 0]) message.pack() def test_unpack(self): pass class TestOFPInstructionWriteMetadata(unittest.TestCase): def test_get_size(self): message = flow_instruction.OFPInstructionWriteMetadata( type=flow_instruction.OFPInstructionsType.OFPIT_WRITE_METADATA, len=24, pad=[0, 0, 0, 0], metadata=1, metadata_mask=1) self.assertEqual(message.get_size(), 24) def test_pack(self): message = flow_instruction.OFPInstructionWriteMetadata( type=flow_instruction.OFPInstructionsType.OFPIT_WRITE_METADATA, len=24, pad=[0, 0, 0, 0], metadata=1, metadata_mask=1) message.pack() def test_unpack(self): pass class TestOFPInstructionActions(unittest.TestCase): def test_get_size(self): message = flow_instruction.OFPInstructionActions( type=flow_instruction.OFPInstructionsType.OFPIT_WRITE_ACTIONS, len=8) self.assertEqual(message.get_size(), 8) def test_pack(self): message = flow_instruction.OFPInstructionActions( type=flow_instruction.OFPInstructionsType.OFPIT_WRITE_ACTIONS, len=8) message.pack() def test_unpack(self): pass