ovsdb-server - Open vSwitch Database Server Protocol
ovsdb-server implements the Open vSwitch Database (OVSDB) protocol
specified in RFC 7047. This document provides clarifications for how
ovsdb-server implements the protocol and describes the extensions that
it provides beyond RFC 7047. Numbers in section headings refer to
corresponding sections in RFC 7047.
RFC 4627 says that names within a JSON object should be unique. The Open vSwitch
JSON parser discards all but the last value for a name that is specified more
than once.
The definition of <error> allows for implementation extensions. Currently
ovsdb-server uses the following additional
error strings (which
might change in later releases):
- syntax error or unknown column
- The request could not be parsed as an OVSDB request. An
additional syntax member, whose value is a string that contains
JSON, may narrow down the particular syntax that could not be parsed.
- internal error
- The request triggered a bug in ovsdb-server.
- ovsdb error
- A map or set contains a duplicate key.
- permission error
- The request was denied by the role-based access control
extension, introduced in version 2.8.
RFC 7047 requires the
version field in <database-schema>. Current
versions of
ovsdb-server allow it to be omitted (future versions are
likely to require it).
RFC 7047 allows columns that contain weak references to be immutable. This
raises the issue of the behavior of the weak reference when the rows that it
references are deleted. Since version 2.6,
ovsdb-server forces columns
that contain weak references to be mutable.
Since version 2.8, the table name
RBAC_Role is used internally by the
role-based access control extension to
ovsdb-server and should not be
used for purposes other than defining mappings of role names to table access
permissions. This table has one row per role name and the following columns:
- name
- The role name.
- permissions
- A map of table name to a reference to a row in a separate
permission table.
The separate RBAC permission table has one row per access control configuration
and the following columns:
- name
- The name of the table to which the row applies.
- authorization
- The set of column names and column:key pairs to be compared
with the client ID in order to determine the authorization status of the
requested operation.
- insert_delete
- A boolean value, true if authorized insertions and
deletions are allowed, false if no insertions or deletions are
allowed.
- update
- The set of columns and column:key pairs for which
authorized update and mutate operations should be permitted.
The original OVSDB specifications included the following reasons, omitted from
RFC 7047, to operate JSON-RPC directly over a stream instead of over HTTP:
- •
- JSON-RPC is a peer-to-peer protocol, but HTTP is a
client-server protocol, which is a poor match. Thus, JSON-RPC over HTTP
requires the client to periodically poll the server to receive server
requests.
- •
- HTTP is more complicated than stream connections and
doesn’t provide any corresponding advantage.
- •
- The JSON-RPC specification for HTTP transport is
incomplete.
Since version 2.8, role-based access controls can be applied to operations
within a transaction that would modify the contents of the database (these
operations include row insert, row delete, column update, and column mutate).
Role-based access controls are applied when the database schema contains a
table with the name
RBAC_Role and the connection on which the
transaction request was received has an associated role name (from the
role column in the remote connection table). When role-based access
controls are enabled, transactions that are otherwise well-formed may be
rejected depending on the client’s role, ID, and the contents of the
RBAC_Role table and associated permissions table.
For backward compatibility,
ovsdb-server currently permits a single
<monitor-request> to be used instead of an array; it is treated as a
single-element array. Future versions of
ovsdb-server might remove this
compatibility feature.
Because the <json-value> parameter is used to match subsequent update
notifications (see below) to the request, it must be unique among all active
monitors.
ovsdb-server rejects attempt to create two monitors with the
same identifier.
When a given client sends a
transact request that changes a table that
the same client is monitoring,
ovsdb-server always sends the
update (or
update2 or
update3) for these changes before
it sends the reply to the
transact request. Thus, when a client
receives a
transact reply, it can know immediately what changes (if
any) the transaction made. (If ovsdb-server might use the other order, then a
client that wishes to act on based on the results of its own transactions
would not know when this was guaranteed to have taken place.)
When a database monitored by a session is removed, and database change awareness
is enabled for the session (see Section 4.1.16), the database server
spontaneously cancels all monitors (including conditional monitors described
in Section 4.1.12) for the removed database. For each canceled monitor, it
issues a notification in the following form:
"method": "monitor_canceled"
"params": [<json-value>]
"id": null
A new monitor method added in Open vSwitch version 2.6. The
monitor_cond
request enables a client to replicate subsets of tables within an OVSDB
database by requesting notifications of changes to rows matching one of the
conditions specified in
where by receiving the specified contents of
these rows when table updates occur.
monitor_cond also allows a more
efficient update notifications by receiving <table-updates2>
notifications (described below).
The
monitor method described in Section 4.1.5 also applies to
monitor_cond, with the following exceptions:
- •
- RPC request method becomes monitor_cond.
- •
- Reply result follows <table-updates2>, described in
Section 4.1.14.
- •
- Subsequent changes are sent to the client using the
update2 monitor notification, described in Section 4.1.14
- •
- Update notifications are being sent only for rows matching
[<condition>*].
The request object has the following members:
"method": "monitor_cond"
"params": [<db-name>, <json-value>, <monitor-cond-requests>]
"id": <nonnull-json-value>
The <json-value> parameter is used to match subsequent update
notifications (see below) to this request. The <monitor-cond-requests>
object maps the name of the table to an array of <monitor-cond-request>.
Each <monitor-cond-request> is an object with the following members:
"columns": [<column>*] optional
"where": [<condition>*] optional
"select": <monitor-select> optional
The
columns, if present, define the columns within the table to be
monitored that match conditions. If not present, all columns are monitored.
The
where, if present, is a JSON array of <condition> and boolean
values. If not present or condition is an empty array, implicit True will be
considered and updates on all rows will be sent.
<monitor-select> is an object with the following members:
"initial": <boolean> optional
"insert": <boolean> optional
"delete": <boolean> optional
"modify": <boolean> optional
The contents of this object specify how the columns or table are to be monitored
as explained in more detail below.
The response object has the following members:
"result": <table-updates2>
"error": null
"id": same "id" as request
The <table-updates2> object is described in detail in Section 4.1.14. It
contains the contents of the tables for which initial rows are selected. If no
tables initial contents are requested, then
result is an empty object.
Subsequently, when changes to a specified table that match one of the conditions
in <monitor-cond-request> are committed, the changes are automatically
sent to the client using the
update2 monitor notification (see Section
4.1.14). This monitoring persists until the JSON-RPC session terminates or
until the client sends a
monitor_cancel JSON-RPC request.
Each <monitor-cond-request> specifies one or more conditions and the
manner in which the rows that match the conditions are to be monitored. The
circumstances in which an
update notification is sent for a row within
the table are determined by <monitor-select>:
- •
- If initial is omitted or true, every row in the
original table that matches one of the conditions is sent as part of the
response to the monitor_cond request.
- •
- If insert is omitted or true, update notifications
are sent for rows newly inserted into the table that match conditions or
for rows modified in the table so that their old version does not match
the condition and new version does.
- •
- If delete is omitted or true, update notifications
are sent for rows deleted from the table that match conditions or for rows
modified in the table so that their old version does match the conditions
and new version does not.
- •
- If modify is omitted or true, update notifications
are sent whenever a row in the table that matches conditions in both old
and new version is modified.
Both
monitor and
monitor_cond sessions can exist concurrently.
However,
monitor and
monitor_cond shares the same
<json-value> parameter space; it must be unique among all
monitor
and
monitor_cond sessions.
The
monitor_cond_change request enables a client to change an existing
monitor_cond replication of the database by specifying a new condition
and columns for each replicated table. Currently changing the columns set is
not supported.
The request object has the following members:
"method": "monitor_cond_change"
"params": [<json-value>, <json-value>, <monitor-cond-update-requests>]
"id": <nonnull-json-value>
The <json-value> parameter should have a value of an existing conditional
monitoring session from this client. The second <json-value> in params
array is the requested value for this session. This value is valid only after
monitor_cond_change is committed. A user can use these values to
distinguish between update messages before conditions update and after. The
<monitor-cond-update-requests> object maps the name of the table to an
array of <monitor-cond-update-request>. Monitored tables not included in
<monitor-cond-update-requests> retain their current conditions.
Each <monitor-cond-update-request> is an object with the following
members:
"columns": [<column>*] optional
"where": [<condition>*] optional
The
columns specify a new array of columns to be monitored, although this
feature is not yet supported.
The
where specify a new array of conditions to be applied to this
monitoring session.
The response object has the following members:
"result": {}
"error": null
"id": same "id" as request
Subsequent <table-updates2> notifications are described in detail in
Section 4.1.14 in the RFC. If insert contents are requested by original
monitor_cond request, <table-updates2> will contain rows that match the
new condition and do not match the old condition. If deleted contents are
requested by origin monitor request, <table-updates2> will contain any
matched rows by old condition and not matched by the new condition.
Changes according to the new conditions are automatically sent to the client
using the
update2 or
update3 monitor notification depending on
the monitor method. An update, if any, as a result of a condition change, will
be sent to the client before the reply to the
monitor_cond_change
request.
The
update2 notification is sent by the server to the client to report
changes in tables that are being monitored following a
monitor_cond
request as described above. The notification has the following members:
"method": "update2"
"params": [<json-value>, <table-updates2>]
"id": null
The <json-value> in
params is the same as the value passed as the
<json-value> in
params for the corresponding
monitor
request. <table-updates2> is an object that maps from a table name to a
<table-update2>. A <table-update2> is an object that maps from
row’s UUID to a <row-update2> object. A <row-update2> is an
object with one of the following members:
- "initial": <row>
- present for initial updates
- "insert": <row>
- present for insert updates
- "delete": <row>
- present for delete updates
- "modify": <row>"
- present for modify updates
The format of <row> is described in Section 5.1.
<row> is always a null object for a
delete update. In
initial and
insert updates, <row> omits columns whose
values equal the default value of the column type.
For a
modify update, <row> contains only the columns that are
modified. <row> stores the difference between the old and new value for
those columns, as described below.
For columns with single value, the difference is the value of the new column.
The difference between two sets are all elements that only belong to one of the
sets.
The difference between two maps are all key-value pairs whose keys appears in
only one of the maps, plus the key-value pairs whose keys appear in both maps
but with different values. For the latter elements, <row> includes the
value from the new column.
Initial views of rows are not presented in update2 notifications, but in the
response object to the
monitor_cond request. The formatting of the
<table-updates2> object, however, is the same in either case.
A new monitor method added in Open vSwitch version 2.12. The
monitor_cond_since request enables a client to request changes that
happened after a specific transaction id. A client can use this feature to
request only latest changes after a server connection reset instead of
re-transfer all data from the server again.
The
monitor_cond method described in Section 4.1.12 also applies to
monitor_cond_since, with the following exceptions:
- •
- RPC request method becomes monitor_cond_since.
- •
- Reply result includes extra parameters.
- •
- Subsequent changes are sent to the client using the
update3 monitor notification, described in Section 4.1.16
The request object has the following members:
"method": "monitor_cond_since"
"params": [<db-name>, <json-value>, <monitor-cond-requests>, <last-txn-id>]
"id": <nonnull-json-value>
The <last-txn-id> parameter is the transaction id that identifies the
latest data the client already has, and it requests server to send changes
AFTER this transaction (exclusive).
All other parameters are the same as
monitor_cond method.
The response object has the following members:
"result": [<found>, <last-txn-id>, <table-updates2>]
"error": null
"id": same "id" as request
The <found> is a boolean value that tells if the <last-txn-id>
requested by client is found in server’s history or not. If true, the
changes after that version up to current is sent. Otherwise, all data is sent.
The <last-txn-id> is the transaction id that identifies the latest
transaction included in the changes in <table-updates2> of this
response, so that client can keep tracking. If there is no change involved in
this response, it is the same as the <last-txn-id> in the request if
<found> is true, or zero uuid if <found> is false. If the server
does not support transaction uuid, it will be zero uuid as well.
All other parameters are the same as in response object of
monitor_cond
method.
Like in
monitor_cond, subsequent changes that match conditions in
<monitor-cond-request> are automatically sent to the client, but using
update3 monitor notification (see Section 4.1.16), instead of
update2.
The
update3 notification is sent by the server to the client to report
changes in tables that are being monitored following a
monitor_cond_since request as described above. The notification has the
following members:
"method": "update3"
"params": [<json-value>, <last-txn-id>, <table-updates2>]
"id": null
The <last-txn-id> is the same as described in the response object of
monitor_cond_since.
All other parameters are the same as in
update2 monitor notification (see
Section 4.1.14).
A new RPC method added in Open vSwitch version 2.7. The request contains the
following members:
"method": "get_server_id"
"params": null
"id": <nonnull-json-value>
The response object contains the following members:
"result": "<server_id>"
"error": null
"id": same "id" as request
<server_id> is JSON string that contains a UUID that uniquely identifies
the running OVSDB server process. A fresh UUID is generated when the process
restarts.
RFC 7047 does not provide a way for a client to find out about some kinds of
configuration changes, such as about databases added or removed while a client
is connected to the server, or databases changing between read/write and
read-only due to a transition between active and backup roles. Traditionally,
ovsdb-server disconnects all of its clients when this happens, because
this prompts a well-written client to reassess what is available from the
server when it reconnects.
OVS 2.9 provides a way for clients to keep track of these kinds of changes, by
monitoring the
Database table in the
_Server database introduced
in this release (see
ovsdb-server(5) for details). By itself, this does
not suppress
ovsdb-server disconnection behavior, because a client
might monitor this database without understanding its special semantics.
Instead,
ovsdb-server provides a special request:
"method": "set_db_change_aware"
"params": [<boolean>]
"id": <nonnull-json-value>
If the boolean in the request is true, it suppresses the connection-closing
behavior for the current connection, and false restores the default behavior.
The reply is always the same:
"result": {}
"error": null
"id": same "id" as request
Open vSwitch 2.9 adds a new JSON-RPC request to convert an online database from
one schema to another. The request contains the following members:
"method": "convert"
"params": [<db-name>, <database-schema>]
"id": <nonnull-json-value>
Upon receipt, the server converts database <db-name> to schema
<database-schema>. The schema’s name must be <db-name>. The
conversion is atomic, consistent, isolated, and durable. The data in the
database must be valid when interpreted under <database-schema>, with
only one exception: data for tables and columns that do not exist in the new
schema are ignored. Columns that exist in <database-schema> but not in
the database are set to their default values. All of the new schema’s
constraints apply in full.
If the conversion is successful, the server notifies clients that use the
set_db_change_aware RPC introduced in Open vSwitch 2.9 and cancels
their outstanding transactions and monitors. The server disconnects other
clients, enabling them to notice the change when they reconnect. The server
sends the following reply:
"result": {}
"error": null
"id": same "id" as request
If the conversion fails, then the server sends an error reply in the following
form:
"result": null
"error": [<error>]
"id": same "id" as request
For <condition>, RFC 7047 only allows the use of
!=,
==,
includes, and
excludes operators with set types. Open vSwitch
2.4 and later extend <condition> to allow the use of
<,
<=,
>=, and
> operators with a column with type
“set of 0 or 1 integer” and an integer argument, and with
“set of 0 or 1 real” and a real argument. These conditions
evaluate to false when the column is empty, and otherwise as described in RFC
7047 for integer and real types.
<condition> is specified in Section 5.1 in the RFC with the following
change: A condition can be either a 3-element JSON array as described in the
RFC or a boolean value. In case of an empty array an implicit true boolean
value will be considered.
As an extension, Open vSwitch 2.13 and later allow an optional
uuid
member to specify the UUID for the new row. The specified UUID must be unique
within the table when it is inserted and not the UUID of a row previously
deleted within the transaction. If the UUID violates these rules, then the
operation fails with a
duplicate uuid error.
RFC 7047 says that the
wait,
commit, and
comment operations
have no corresponding result object. This is not true. Instead, when such an
operation is successful, it yields a result object with no members.
The Open vSwitch Development Community
2016-2024, The Open vSwitch Development Community