netrack/openflow

The OpenFlow middleware library

openflow - The OpenFlow protocol library

The openflow library is a pure Go implementation of the OpenFlow protocol. The ideas of the programming interface mostly borrowed from the Go standard HTTP library.

Installation

$ go get github.com/netrack/openflow

Usage

The usage is pretty similar to the handling HTTP request, but instead of routes we are using message types.

package main

import (
    of "github.com/netrack/openflow"
)

func main() {
    // Define the OpenFlow handler for hello messages.
    of.HandleFunc(of.TypeHello, func(rw of.ResponseWriter, r *of.Request) {
        // Send back hello response.
        rw.Write(&of.Header{Type: of.TypeHello}, nil)
    })

    // Start the TCP server on 6633 port.
    of.ListenAndServe(":6633", nil)
}

package main

import (
    "github.com/netrack/openflow/ofp"
    of "github.com/netrack/openflow"
)

func main() {
    pattern := of.TypeMatcher(of.TypePacketIn)

    mux := of.NewServeMux()
    mux.HandleFunc(pattern, func(rw of.ResponseWriter, r *of.Request) {
        var packet ofp.PacketIn
        packet.ReadFrom(r.Body)

        apply := &ofp.InstructionApplyActions{
            ofp.Actions{&ofp.ActionOutput{ofp.PortFlood, 0}},
        }

        // For each incoming packet-in request, create a
        // respective flow modification command.
        fmod := ofp.NewFlowMod(ofp.FlowAdd, packet)
        fmod.Instructions = ofp.Instructions{apply}

        rw.Write(&of.Header{Type: of.TypeFlowMod}, fmod)
    })

    of.ListenAndServe(":6633", mux)
}

License

The openflow library is distributed under MIT license, therefore you are free to do with code whatever you want. See the LICENSE file for full license text.

openflow's Issues

Update documentation of port configuration and statistics

Need to update the documentation of port configuration and statistics message. It would be nice to write a few examples how to retrieve port configuration or statistics from the switch.

Update documentation of table modification and table features messages

The table modification and table features messages are lack of Go documentation. It would be neat to add a few examples if possible.

Update documentation of switch features and configuration

Need to update the documentation of switch features and configuration. A few example of how to retrieve mentioned switch information are highly appreciated.

Make ListenAndServe function accept address and handler.

In the current implementation ListenAndServe function does not accept any parameters. On one hand it is pretty simple, but not really useful, thus require refactoring.

The usage of the resulting function should look like the doppelganger from net/http package:

func ListenAndServe(addr string, handler Handler) error

Note, the server implementation could be required to accept nil value as handler parameter.

readTablePropXM() Shouldn't Read a Payload

Matches read as part of ofp_table_feature_prop_oxm should not include a payload.

From the spec (emphasis mine):
"The oxm_ids is the list of OXM types for the feature (see 7.2.3.2). The elements of that list are 32-bit
OXM headers for non-experimenter OXM fields or 64-bit OXM headers for experimenter OXM fields,
those OXM fields don’t include any payload."

These Matches are currently read assuming a payload, causing errors.

(Pull request WIP.)

DefaultHandler instead of DiscardHandler

Small nit but it seems intuitive to me that all references to DiscardHandler should instead be named DefaultHandler.

func DiscardHandler(rw ResponseWriter, r *Request) {}

var DefaultHandler = DiscardHandler

s/DiscardHandler/DefaultHandler

we can then override an externally visible DefaultHandler which makes more sense than overriding DiscardHandler.

Support OpenFlow from 1.0 to 1.5?

Does this project support OpenFlow from 1.0 to 1.5? Or only support a certain version, such as 1.3?

Update documentation of flow instructions

Need to update the documentation for flow instructions. The changes may assume a few examples.

Update documentation of queue statistics and configuration

The queue statistics and configuration messages are lack of required documentation. The changes have to ship a few examples how to retrieve queue statistics and configuration.

OF messages received from the switch should be treated concurrently not sequentially

openflow/server.go

Line 266 in e388199

// sequentially. When error is returned from the receive loop, this

Double counting in table.go

Is this double counting?

nn, err := encoding.WriteSliceTo(w, xms) if n += nn; err != nil { return n + nn, err <------------ }
https://github.com/netrack/openflow/blob/master/ofp/table.go#L324

Only happens on error. But I am curious if there is a purpose? If so I can send a fix, have it ready.

Update documentation of hello messages and role change request

Need to update the documentation for messages used to perform a handshake routine. Examples will be highly appreciated.

Update documentation of extensible match

Need to update the documentation of flow extensible match. The changes may assume a few examples.

Update the documentation of OpenFlow description

Need to provide a relevant documentation for switch description message with an example if possible.

Add a TravisCI integration

Each pull request have to pass all unit and integration tests before merge into the public branches.

Make net.go:conn.Send() thread safe

TablePropTypes above 9 and inclusive are incorrect.

It seems Openflow does not have property 9 and 11. Will send fix soon.

Update documentation of meter configuration and meter statistics

Need to update the documentation of meter configuration and meter statistics messages. The changes should assume relevant examples.

Create integration tests

The library more or less is covered with unit tests, but is lack of integration tests, therefore in terms of this issue, should be introduced integration tests with Open V-Switch, that cover some scenario of communication between the data plane and control plane.

Also, the tests should require minimal configuration of the development environment. Ideally, it would be nice to describe environment using Dockerfile.

Cookie match for multipart requests

During the implementation of the integration tests notices the problem with registering disposable handler for multipart requests.

Initially, I thought to use the NewCookieMatcher to match the multipart response, but ofp.MultipartRequest header does not implement CookieJar interface, while the body of multipart request does (e.g. AggregateStatsRequest).

Need a solution how to register disposable handler for multipart responses.

Update documentation of group modification and group statistics

Need to update the documentation for group modification and group statistics messages. The changes must include the relevant examples.

Update the documentation of OpenFlow aggregated statistic

Need to provide a relevant documentation for aggregates statistics messages with a few examples if possible.

consolidate package naming to either "of" or "openflow"

I suggest "openflow".
If other packages want to use a shorter name they can name the import:
of "netrack/openflow"

one strange example is "ofputil/handler.go" where it imports "openflow", but the package is defined as "of".

Go report messaged 32 issues across 60 files

The issues should be fixed (includes misspelling, formatting, vetting, etc.). The details could be found by this link: https://goreportcard.com/report/github.com/netrack/openflow#misspell.

Update documentation of multipart request/reply messages

Need to update documentation of multipart request and reply messages with a few relevant examples if possible.

Identifiers should not use camel case instead of all caps

Identifiers in the match.go file should be modified to pass golint validations:

ofp.v13/match.go:162:2: don't use ALL_CAPS in Go names; use CamelCase
ofp.v13/match.go:165:2: don't use ALL_CAPS in Go names; use CamelCase
ofp.v13/match.go:177:2: don't use ALL_CAPS in Go names; use CamelCase
ofp.v13/match.go:180:2: don't use ALL_CAPS in Go names; use CamelCase
ofp.v13/match.go:183:2: don't use ALL_CAPS in Go names; use CamelCase
ofp.v13/match.go:186:2: don't use ALL_CAPS in Go names; use CamelCase
ofp.v13/match.go:189:2: don't use ALL_CAPS in Go names; use CamelCase
ofp.v13/match.go:192:2: don't use ALL_CAPS in Go names; use CamelCase
ofp.v13/match.go:195:2: don't use ALL_CAPS in Go names; use CamelCase
ofp.v13/match.go:198:2: don't use ALL_CAPS in Go names; use CamelCase
ofp.v13/match.go:201:2: don't use ALL_CAPS in Go names; use CamelCase

Create a package "ofputil" with HelloHandler and EchoHandler functions

A new package should consist of at least two following functions:

• func HelloHandler() of.Handler to submit OFP hello messages.
• func EchoHandler() of.Handler to submit OFP echo-reply messages.

Update documentation for flow modification, flow statistics command

Need to update documentation for flow modification and flow statistics commands. The documentation should include a few examples.

Update documentation of packet in/out messages

Need to update documentation of packet in/out message. A few examples are highly appreciated.

Update the documentation for OpenFlow actions

After the recent changes in the ofp/actions.go file, documentation for Actions become outdated, it have to be updated with relevant information and, probably, few examples.

Table features generated messages seems incorrect

I was expecting the following to work. But it does not. =(

ofp.TableFeatures{
		Table:      0,
		Name:       "Table0",
		MaxEntries: 1000,
		Properties: []ofp.TableProp{
			ofp.TableProp(&ofp.TablePropInstructions{
				Instructions: ofp.Instructions{
					ofp.Instruction(&ofp.InstructionApplyActions{}),
				},
			}),
		},
},

The generated packet has extra junk after InstructionApplyActions{}.

The shortest workaround is to prevent the extra fields from being serialized. Example:

type InstructionApplyActions struct{ ofp.InstructionApplyActions }

func (i *InstructionApplyActions) WriteTo(w io.Writer) (int64, error) {
	return encoding.WriteTo(w, i.Type(), uint16(4))
}

The workaround is feasible but expensive. Any alternative option? This issue is consistent with most if not all of the fields used in TablePropInstructions.

Update documentation of OpenFlow errors

Need to write documentation for error types and error codes.

Create a uniform function to align the messages

The OpenFlow specification mentions about the message padding, that forces some
of the structures with variable size to be aligned up to 8-byte boundary. Currently the
ofp package does not have any uniform approach to deal with it, instead it contains
copy-pasted snippets, like this one below:

padding := make([]byte, (header.Len+7)/8*8-header.Len)
nn, err := encoding.ReadFrom(r, padding)

Therefore, it would be better to refactor this part and introduce a new function as part of
the encoding package, that will handle this automatically (e.g. ReadFullFrom(r, &values, 8)).

Update documentation of OpenFlow echo request/reply

Need to update the godoc for echo request and reply messages with a relevant example.

Question: Was the OFP code generated or hand coded?

Curious =)