libovsdb

package module
v0.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 18, 2019 License: Apache-2.0 Imports: 14 Imported by: 4

README

libovsdb

Travis-CI

An OVSDB Library written in Go

Purpose of Fork of Original libovsdb

eBay wishes to thank the original authors of libovsdb. The original library is found here:

https://github.com/socketplane/libovsdb/

This fork has been created to encourage changes and patches to ensure this version of the library works with go-ovn.

What is OVSDB?

OVSDB is the Open vSwitch Database Protocol. It's defined in RFC 7047 It's used mainly for managing the configuration of Open vSwitch, but it could also be used to manage your stamp collection. Philatelists Rejoice!

## Running the tests

To run integration tests, you'll need access to docker to run an Open vSwitch container. Mac users can use boot2docker

export DOCKER_IP=$(boot2docker ip)

docker-compose run test /bin/sh
# make test-local
...
# exit
docker-compose down

By invoking the command make, you will automatically get the same behaviour as what is shown above. In other words, it will start the two containers and execute make test-local from the test container.

Dependency Management

We use godep for dependency management with rewritten import paths. This allows the repo to be go getable.

To bump the version of a dependency, follow these instructions

License

Modifications Copyright 2018-2019 eBay Inc.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

https://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Third Party Code Attribution and Licenses

This software contains code licensed by third parties. In particular, see https://github.com/socketplane/libovsdb.

Original contributors/maintainers: Dave Tucker, Madhu Venugopal, Sukhesh Halemane

This software consists of voluntary contributions made by many individuals. For exact contribution history, see the commit history.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

https://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. https://github.com/socketplane/libovsdb/blob/master/LICENSE

Documentation

Index

Constants

View Source 
const (
	SSL  = "ssl"
	TCP  = "tcp"
	UNIX = "unix"
)

Variables

This section is empty.

Functions

func NewCancelArgs 

func NewCancelArgs(id interface{}) []interface{}

NewCancelArgs creates a new set of arguments for a cancel RPC

func NewCondition 

func NewCondition(column string, function string, value interface{}) []interface{}

NewCondition creates a new condition as specified in RFC7047

func NewGetSchemaArgs 

func NewGetSchemaArgs(schema string) []interface{}

NewGetSchemaArgs creates a new set of arguments for a get_schemas RPC

func NewLockArgs 

func NewLockArgs(id interface{}) []interface{}

NewLockArgs creates a new set of arguments for a lock, steal or unlock RPC

func NewMonitorArgs 

func NewMonitorArgs(database string, value interface{}, requests map[string]MonitorRequest) []interface{}

NewMonitorArgs creates a new set of arguments for a monitor RPC

func NewMonitorCancelArgs 

func NewMonitorCancelArgs(value interface{}) []interface{}

NewMonitorCancelArgs creates a new set of arguments for a monitor_cancel RPC

func NewMutation 

func NewMutation(column string, mutator string, value interface{}) []interface{}

NewMutation creates a new mutation as specified in RFC7047

func NewTransactArgs 

func NewTransactArgs(database string, operations ...Operation) []interface{}

NewTransactArgs creates a new set of arguments for a transact RPC

Types

type ColumnSchema 

type ColumnSchema struct {
	Name      string      `json:"name"`
	Type      interface{} `json:"type"`
	Ephemeral bool        `json:"ephemeral,omitempty"`
	Mutable   bool        `json:"mutable,omitempty"`
}

ColumnSchema is a column schema according to RFC7047

type Config 

type Config struct {
	Addr      string
	TLSConfig *tls.Config
}

type DatabaseSchema 

type DatabaseSchema struct {
	Name    string                 `json:"name"`
	Version string                 `json:"version"`
	Tables  map[string]TableSchema `json:"tables"`
}

DatabaseSchema is a database schema according to RFC7047

func (DatabaseSchema) Print 

func (schema DatabaseSchema) Print(w io.Writer)

Print will print the contents of the DatabaseSchema

type MonitorRequest 

type MonitorRequest struct {
	Columns []string      `json:"columns,omitempty"`
	Select  MonitorSelect `json:"select,omitempty"`
}

MonitorRequest represents a monitor request according to RFC7047

type MonitorRequests 

type MonitorRequests struct {
	Requests map[string]MonitorRequest `json:"requests,overflow"`
}

MonitorRequests represents a group of monitor requests according to RFC7047 We cannot use MonitorRequests by inlining the MonitorRequest Map structure till GoLang issue #6213 makes it. The only option is to go with raw map[string]interface{} option :-( that sucks ! Refer to client.go : MonitorAll() function for more details

type MonitorSelect 

type MonitorSelect struct {
	Initial bool `json:"initial,omitempty"`
	Insert  bool `json:"insert,omitempty"`
	Delete  bool `json:"delete,omitempty"`
	Modify  bool `json:"modify,omitempty"`
}

MonitorSelect represents a monitor select according to RFC7047

type NotificationHandler 

type NotificationHandler interface {
	// RFC 7047 section 4.1.6 Update Notification
	Update(context interface{}, tableUpdates TableUpdates)

	// RFC 7047 section 4.1.9 Locked Notification
	Locked([]interface{})

	// RFC 7047 section 4.1.10 Stolen Notification
	Stolen([]interface{})

	// RFC 7047 section 4.1.11 Echo Notification
	Echo([]interface{})

	Disconnected(*OvsdbClient)
}

NotificationHandler is the interface that must be implemented to receive notifcations

type Operation 

type Operation struct {
	Op        string                   `json:"op"`
	Table     string                   `json:"table"`
	Row       map[string]interface{}   `json:"row,omitempty"`
	Rows      []map[string]interface{} `json:"rows,omitempty"`
	Columns   []string                 `json:"columns,omitempty"`
	Mutations []interface{}            `json:"mutations,omitempty"`
	Timeout   int                      `json:"timeout,omitempty"`
	Where     []interface{}            `json:"where,omitempty"`
	Until     string                   `json:"until,omitempty"`
	UUIDName  string                   `json:"uuid-name,omitempty"`
}

Operation represents an operation according to RFC7047 section 5.2

func (Operation) MarshalJSON 

func (o Operation) MarshalJSON() ([]byte, error)

MarshalJSON marshalls 'Operation' to a byte array For 'select' operations, we dont omit the 'Where' field to allow selecting all rows of a table

type OperationResult 

type OperationResult struct {
	Count   int         `json:"count,omitempty"`
	Error   string      `json:"error,omitempty"`
	Details string      `json:"details,omitempty"`
	UUID    UUID        `json:"uuid,omitempty"`
	Rows    []ResultRow `json:"rows,omitempty"`
}

OperationResult is the result of an Operation

type OvsMap 

type OvsMap struct {
	GoMap map[interface{}]interface{}
}

OvsMap is the JSON map structure used for OVSDB RFC 7047 uses the following notation for map as JSON doesnt support non-string keys for maps. A 2-element JSON array that represents a database map value. The first element of the array must be the string "map", and the second element must be an array of zero or more <pair>s giving the values in the map. All of the <pair>s must have the same key and value types.

func NewOvsMap 

func NewOvsMap(goMap interface{}) (*OvsMap, error)

NewOvsMap will return an OVSDB style map from a provided Golang Map

func (OvsMap) MarshalJSON 

func (o OvsMap) MarshalJSON() ([]byte, error)

MarshalJSON marshalls an OVSDB style Map to a byte array

func (*OvsMap) UnmarshalJSON 

func (o *OvsMap) UnmarshalJSON(b []byte) (err error)

UnmarshalJSON unmarshalls an OVSDB style Map from a byte array

type OvsSet 

type OvsSet struct {
	GoSet []interface{}
}

OvsSet is an OVSDB style set RFC 7047 has a wierd (but understandable) notation for set as described as : Either an <atom>, representing a set with exactly one element, or a 2-element JSON array that represents a database set value. The first element of the array must be the string "set", and the second element must be an array of zero or more <atom>s giving the values in the set. All of the <atom>s must have the same type.

func NewOvsSet 

func NewOvsSet(goSlice interface{}) (*OvsSet, error)

NewOvsSet creates a new OVSDB style set from a Go slice

func (OvsSet) MarshalJSON 

func (o OvsSet) MarshalJSON() ([]byte, error)

MarshalJSON wil marshal an OVSDB style set in to a JSON byte array

func (*OvsSet) UnmarshalJSON 

func (o *OvsSet) UnmarshalJSON(b []byte) (err error)

UnmarshalJSON will unmarshal a JSON byte array to an OVSDB style set

type OvsdbClient 

type OvsdbClient struct {
	Schema map[string]DatabaseSchema
	// contains filtered or unexported fields
}

OvsdbClient is an OVSDB client

func Connect 

func Connect(endpoints string, tlsConfig *tls.Config) (*OvsdbClient, error)

Connect to ovn, using endpoint in format ovsdb Connection Methods If address is empty, use default address for specified protocol

func (OvsdbClient) Disconnect 

func (ovs OvsdbClient) Disconnect()

Disconnect will close the OVSDB connection

func (OvsdbClient) GetSchema 

func (ovs OvsdbClient) GetSchema(dbName string) (*DatabaseSchema, error)

GetSchema returns the schema in use for the provided database name RFC 7047 : get_schema

func (OvsdbClient) ListDbs 

func (ovs OvsdbClient) ListDbs() ([]string, error)

ListDbs returns the list of databases on the server RFC 7047 : list_dbs

func (OvsdbClient) Monitor 

func (ovs OvsdbClient) Monitor(database string, jsonContext interface{}, requests map[string]MonitorRequest) (*TableUpdates, error)

Monitor will provide updates for a given table/column RFC 7047 : monitor

func (OvsdbClient) MonitorAll 

func (ovs OvsdbClient) MonitorAll(database string, jsonContext interface{}) (*TableUpdates, error)

MonitorAll is a convenience method to monitor every table/column

func (OvsdbClient) MonitorCancel 

func (ovs OvsdbClient) MonitorCancel(database string, jsonContext interface{}) error

MonitorCancel will request cancel a previously issued monitor request RFC 7047 : monitor_cancel

func (*OvsdbClient) Register 

func (ovs *OvsdbClient) Register(handler NotificationHandler)

Register registers the supplied NotificationHandler to recieve OVSDB Notifications

func (OvsdbClient) Transact 

func (ovs OvsdbClient) Transact(database string, operation ...Operation) ([]OperationResult, error)

Transact performs the provided Operation's on the database RFC 7047 : transact

func (*OvsdbClient) Unregister 

func (ovs *OvsdbClient) Unregister(handler NotificationHandler) error

Unregister the supplied NotificationHandler to not recieve OVSDB Notifications anymore

type OvsdbError 

type OvsdbError struct {
	Error   string `json:"error"`
	Details string `json:"details,omitempty"`
}

OvsdbError is an OVS Error Condition

type ResultRow 

type ResultRow map[string]interface{}

ResultRow is an properly unmarshalled row returned by Transact

func (*ResultRow) UnmarshalJSON 

func (r *ResultRow) UnmarshalJSON(b []byte) (err error)

UnmarshalJSON unmarshalls a byte array to an OVSDB Row

type Row 

type Row struct {
	Fields map[string]interface{}
}

Row is a table Row according to RFC7047

func (*Row) UnmarshalJSON 

func (r *Row) UnmarshalJSON(b []byte) (err error)

UnmarshalJSON unmarshalls a byte array to an OVSDB Row

type RowUpdate 

type RowUpdate struct {
	UUID UUID `json:"-,omitempty"`
	New  Row  `json:"new,omitempty"`
	Old  Row  `json:"old,omitempty"`
}

RowUpdate represents a row update according to RFC7047

type TableSchema 

type TableSchema struct {
	Columns map[string]ColumnSchema `json:"columns"`
	Indexes [][]string              `json:"indexes,omitempty"`
}

TableSchema is a table schema according to RFC7047

type TableUpdate 

type TableUpdate struct {
	Rows map[string]RowUpdate `json:"rows,overflow"`
}

TableUpdate represents a table update according to RFC7047

type TableUpdates 

type TableUpdates struct {
	Updates map[string]TableUpdate `json:"updates,overflow"`
}

TableUpdates is a collection of TableUpdate entries We cannot use TableUpdates directly by json encoding by inlining the TableUpdate Map structure till GoLang issue #6213 makes it. The only option is to go with raw map[string]map[string]interface{} option :-( that sucks ! Refer to client.go : MonitorAll() function for more details

type TransactResponse 

type TransactResponse struct {
	Result []OperationResult `json:"result"`
	Error  string            `json:"error"`
}

TransactResponse represents the response to a Transact Operation

type UUID 

type UUID struct {
	GoUUID string `json:"uuid"`
}

UUID is a UUID according to RFC7047

func (UUID) MarshalJSON 

func (u UUID) MarshalJSON() ([]byte, error)

MarshalJSON will marshal an OVSDB style UUID to a JSON encoded byte array

func (*UUID) UnmarshalJSON 

func (u *UUID) UnmarshalJSON(b []byte) (err error)

UnmarshalJSON will unmarshal a JSON encoded byte array to a OVSDB style UUID

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.