2406 lines
88 KiB
Python
2406 lines
88 KiB
Python
# Copyright (C) 2012 Nippon Telegraph and Telephone Corporation.
|
|
# Copyright (C) 2012 Isaku Yamahata <yamahata at private email ne jp>
|
|
#
|
|
# 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
|
|
#
|
|
# http://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.
|
|
|
|
"""
|
|
``ovs-vsctl`` command like library to speak OVSDB protocol
|
|
"""
|
|
|
|
from __future__ import print_function
|
|
|
|
import logging
|
|
import operator
|
|
import os
|
|
import re
|
|
import sys
|
|
import weakref
|
|
|
|
import six
|
|
|
|
import ovs.db.data
|
|
import ovs.db.parser
|
|
import ovs.db.schema
|
|
import ovs.db.types
|
|
import ovs.poller
|
|
import ovs.json
|
|
from ovs import jsonrpc
|
|
from ovs import ovsuuid
|
|
from ovs import stream
|
|
from ovs.db import idl
|
|
|
|
from ryu.lib import hub
|
|
from ryu.lib import ip
|
|
from ryu.lib.ovs import vswitch_idl
|
|
from ryu.lib.stringify import StringifyMixin
|
|
|
|
|
|
LOG = logging.getLogger(__name__) # use ovs.vlog?
|
|
|
|
|
|
def valid_ovsdb_addr(addr):
|
|
"""
|
|
Returns True if the given addr is valid OVSDB server address, otherwise
|
|
False.
|
|
|
|
The valid formats are:
|
|
|
|
- ``unix:file``
|
|
- ``tcp:ip:port``
|
|
- ``ssl:ip:port``
|
|
|
|
If ip is IPv6 address, wrap ip with brackets (e.g., ssl:[::1]:6640).
|
|
|
|
:param addr: str value of OVSDB server address.
|
|
:return: True if valid, otherwise False.
|
|
"""
|
|
# Assumes Unix socket format: "unix:file"
|
|
m = re.match(r'unix:(\S+)', addr)
|
|
if m:
|
|
file = m.group(1)
|
|
return os.path.isfile(file)
|
|
# Assumes TCP/SSL socket format: "tcp:ip:port" or "ssl:ip:port"
|
|
m = re.match(r'(tcp|ssl):(\S+):(\d+)', addr)
|
|
if m:
|
|
address = m.group(2)
|
|
port = m.group(3)
|
|
if '[' in address:
|
|
address = address.strip('[').strip(']')
|
|
return ip.valid_ipv6(address) and port.isdigit()
|
|
else:
|
|
return ip.valid_ipv4(address) and port.isdigit()
|
|
# Assumes invalid format or unsupported type
|
|
return False
|
|
|
|
|
|
# for debug
|
|
def ovsrec_row_changes_to_string(ovsrec_row):
|
|
if not ovsrec_row._changes:
|
|
return ovsrec_row._changes
|
|
|
|
return dict((key, value.to_string())
|
|
for key, value in ovsrec_row._changes.items())
|
|
|
|
|
|
# for debug
|
|
def ovsrec_row_to_string(ovsrec_row):
|
|
output = ''
|
|
output += 'uuid: %s ' % ovsrec_row.uuid
|
|
if ovsrec_row._data:
|
|
output += '_data: %s ' % dict((key, value.to_string()) for key, value
|
|
in ovsrec_row._data.items())
|
|
else:
|
|
output += '_data: %s ' % ovsrec_row._data
|
|
output += '_changes: %s' % ovsrec_row_changes_to_string(ovsrec_row)
|
|
return output
|
|
|
|
|
|
def atom_from_string(base, value_string, symtab=None):
|
|
type_ = base.type
|
|
atom = None
|
|
if type_ == ovs.db.types.IntegerType:
|
|
atom = ovs.db.data.Atom(type_, int(value_string))
|
|
elif type_ == ovs.db.types.RealType:
|
|
# TODO:XXX negation
|
|
atom = ovs.db.data.Atom(
|
|
type_, ovs.db.parser.float_to_int(float(value_string)))
|
|
elif type_ == ovs.db.types.BooleanType:
|
|
if value_string in ("true", "yes", "on", "1"):
|
|
atom = ovs.db.data.Atom(type_, True)
|
|
elif value_string == ("false", "no", "off", "0"):
|
|
atom = ovs.db.data.Atom(type_, False)
|
|
elif type_ == ovs.db.types.StringType:
|
|
# TODO:XXXX escape: if value_string[0] == '"':
|
|
atom = ovs.db.data.Atom(type_, value_string)
|
|
elif type_ == ovs.db.types.UuidType:
|
|
if value_string[0] == "@":
|
|
assert symtab is not None
|
|
uuid_ = symtab[value_string]
|
|
atom = ovs.db.data.Atom(type_, uuid_)
|
|
else:
|
|
atom = ovs.db.data.Atom(type_,
|
|
ovs.ovsuuid.from_string(value_string))
|
|
if atom is None:
|
|
raise ValueError("expected %s" % type_.to_string(), value_string)
|
|
atom.check_constraints(base)
|
|
return atom
|
|
|
|
|
|
def datum_from_string(type_, value_string, symtab=None):
|
|
value_string = value_string.strip()
|
|
if type_.is_map():
|
|
if value_string.startswith('{'):
|
|
# TODO:dict case
|
|
LOG.debug('value_string %s', value_string)
|
|
raise NotImplementedError()
|
|
d = dict(v.split('=', 1) for v in value_string.split(','))
|
|
d = dict((atom_from_string(type_.key, key, symtab),
|
|
atom_from_string(type_.value, value, symtab))
|
|
for key, value in d.items())
|
|
elif type_.is_set():
|
|
if value_string.startswith('['):
|
|
# TODO:set case
|
|
LOG.debug('value_string %s', value_string)
|
|
raise NotImplementedError()
|
|
values = value_string.split(',')
|
|
d = dict((atom_from_string(type_.key, value, symtab), None)
|
|
for value in values)
|
|
else:
|
|
atom = atom_from_string(type_.key, value_string, symtab)
|
|
d = {atom: None}
|
|
|
|
datum = ovs.db.data.Datum(type_, d)
|
|
return datum.to_json()
|
|
|
|
|
|
def ifind(pred, seq):
|
|
try:
|
|
return [i for i in seq if pred(i)][0]
|
|
except IndexError:
|
|
return None
|
|
|
|
|
|
def not_reached():
|
|
os.abort()
|
|
|
|
|
|
def vsctl_fatal(msg):
|
|
LOG.error(msg)
|
|
raise Exception(msg) # not call ovs.utils.ovs_fatal for reusability
|
|
|
|
|
|
class VSCtlBridge(object):
|
|
|
|
def __init__(self, ovsrec_bridge, name, parent, vlan):
|
|
super(VSCtlBridge, self).__init__()
|
|
self.br_cfg = ovsrec_bridge
|
|
self.name = name
|
|
self.ports = set()
|
|
self.parent = parent
|
|
self.vlan = vlan
|
|
self.children = set() # WeakSet is needed?
|
|
|
|
def find_vlan_bridge(self, vlan):
|
|
return ifind(lambda child: child.vlan == vlan, self.children)
|
|
|
|
|
|
class VSCtlPort(object):
|
|
|
|
def __init__(self, vsctl_bridge_parent, ovsrec_port):
|
|
super(VSCtlPort, self).__init__()
|
|
self.bridge = weakref.ref(vsctl_bridge_parent) # backpointer
|
|
self.port_cfg = ovsrec_port
|
|
|
|
self.ifaces = set()
|
|
self.qos = None
|
|
|
|
|
|
class VSCtlIface(object):
|
|
|
|
def __init__(self, vsctl_port_parent, ovsrec_iface):
|
|
super(VSCtlIface, self).__init__()
|
|
self.port = weakref.ref(vsctl_port_parent) # backpointer
|
|
self.iface_cfg = ovsrec_iface
|
|
|
|
|
|
class VSCtlQoS(object):
|
|
|
|
def __init__(self, vsctl_port_parent, ovsrec_qos):
|
|
super(VSCtlQoS, self).__init__()
|
|
self.port = weakref.ref(vsctl_port_parent)
|
|
self.qos_cfg = ovsrec_qos
|
|
self.queues = set()
|
|
|
|
|
|
class VSCtlQueue(object):
|
|
|
|
def __init__(self, vsctl_qos_parent, ovsrec_queue):
|
|
super(VSCtlQueue, self).__init__()
|
|
self.qos = weakref.ref(vsctl_qos_parent)
|
|
self.queue_cfg = ovsrec_queue
|
|
|
|
|
|
class VSCtlContext(object):
|
|
|
|
def _invalidate_cache(self):
|
|
self.cache_valid = False
|
|
self.bridges.clear()
|
|
self.ports.clear()
|
|
self.ifaces.clear()
|
|
|
|
def __init__(self, idl_, txn, ovsrec_open_vswitch):
|
|
super(VSCtlContext, self).__init__()
|
|
|
|
# Modifiable state
|
|
# self.table = None
|
|
self.idl = idl_
|
|
self.txn = txn
|
|
self.ovs = ovsrec_open_vswitch
|
|
self.symtab = None # TODO:XXX
|
|
self.verified_ports = False
|
|
|
|
# A cache of the contents of the database.
|
|
self.cache_valid = False
|
|
self.bridges = {} # bridge name -> VSCtlBridge
|
|
self.ports = {} # port name -> VSCtlPort
|
|
self.ifaces = {} # iface name -> VSCtlIface
|
|
|
|
self.try_again = False # used by wait-until command
|
|
|
|
def done(self):
|
|
self._invalidate_cache()
|
|
|
|
def verify_bridges(self):
|
|
self.ovs.verify(vswitch_idl.OVSREC_OPEN_VSWITCH_COL_BRIDGES)
|
|
|
|
def verify_ports(self):
|
|
if self.verified_ports:
|
|
return
|
|
|
|
self.verify_bridges()
|
|
for ovsrec_bridge in self.idl.tables[
|
|
vswitch_idl.OVSREC_TABLE_BRIDGE].rows.values():
|
|
ovsrec_bridge.verify(vswitch_idl.OVSREC_BRIDGE_COL_PORTS)
|
|
for ovsrec_port in self.idl.tables[
|
|
vswitch_idl.OVSREC_TABLE_PORT].rows.values():
|
|
ovsrec_port.verify(vswitch_idl.OVSREC_PORT_COL_INTERFACES)
|
|
self.verified_ports = True
|
|
|
|
def add_bridge_to_cache(self, ovsrec_bridge, name, parent, vlan):
|
|
vsctl_bridge = VSCtlBridge(ovsrec_bridge, name, parent, vlan)
|
|
if parent:
|
|
parent.children.add(vsctl_bridge)
|
|
self.bridges[name] = vsctl_bridge
|
|
return vsctl_bridge
|
|
|
|
def del_cached_bridge(self, vsctl_bridge):
|
|
assert not vsctl_bridge.ports
|
|
assert not vsctl_bridge.children
|
|
|
|
parent = vsctl_bridge.parent
|
|
if parent:
|
|
parent.children.remove(vsctl_bridge)
|
|
vsctl_bridge.parent = None # break circular reference
|
|
ovsrec_bridge = vsctl_bridge.br_cfg
|
|
if ovsrec_bridge:
|
|
ovsrec_bridge.delete()
|
|
self.ovs_delete_bridge(ovsrec_bridge)
|
|
|
|
del self.bridges[vsctl_bridge.name]
|
|
|
|
def del_cached_qos(self, vsctl_qos):
|
|
vsctl_qos.port().qos = None
|
|
vsctl_qos.port = None
|
|
vsctl_qos.queues = None
|
|
|
|
def add_port_to_cache(self, vsctl_bridge_parent, ovsrec_port):
|
|
tag = getattr(ovsrec_port, vswitch_idl.OVSREC_PORT_COL_TAG, None)
|
|
if isinstance(tag, list):
|
|
if len(tag) == 0:
|
|
tag = 0
|
|
else:
|
|
tag = tag[0]
|
|
if tag is not None and 0 <= tag < 4096:
|
|
vlan_bridge = vsctl_bridge_parent.find_vlan_bridge(tag)
|
|
if vlan_bridge:
|
|
vsctl_bridge_parent = vlan_bridge
|
|
|
|
vsctl_port = VSCtlPort(vsctl_bridge_parent, ovsrec_port)
|
|
vsctl_bridge_parent.ports.add(vsctl_port)
|
|
self.ports[ovsrec_port.name] = vsctl_port
|
|
return vsctl_port
|
|
|
|
def del_cached_port(self, vsctl_port):
|
|
assert not vsctl_port.ifaces
|
|
vsctl_port.bridge().ports.remove(vsctl_port)
|
|
vsctl_port.bridge = None
|
|
port = self.ports.pop(vsctl_port.port_cfg.name)
|
|
assert port == vsctl_port
|
|
vsctl_port.port_cfg.delete()
|
|
|
|
def add_iface_to_cache(self, vsctl_port_parent, ovsrec_iface):
|
|
vsctl_iface = VSCtlIface(vsctl_port_parent, ovsrec_iface)
|
|
vsctl_port_parent.ifaces.add(vsctl_iface)
|
|
self.ifaces[ovsrec_iface.name] = vsctl_iface
|
|
|
|
def add_qos_to_cache(self, vsctl_port_parent, ovsrec_qos):
|
|
vsctl_qos = VSCtlQoS(vsctl_port_parent, ovsrec_qos)
|
|
vsctl_port_parent.qos = vsctl_qos
|
|
return vsctl_qos
|
|
|
|
def add_queue_to_cache(self, vsctl_qos_parent, ovsrec_queue):
|
|
vsctl_queue = VSCtlQueue(vsctl_qos_parent, ovsrec_queue)
|
|
vsctl_qos_parent.queues.add(vsctl_queue)
|
|
|
|
def del_cached_iface(self, vsctl_iface):
|
|
vsctl_iface.port().ifaces.remove(vsctl_iface)
|
|
vsctl_iface.port = None
|
|
del self.ifaces[vsctl_iface.iface_cfg.name]
|
|
vsctl_iface.iface_cfg.delete()
|
|
|
|
def invalidate_cache(self):
|
|
if not self.cache_valid:
|
|
return
|
|
self._invalidate_cache()
|
|
|
|
def populate_cache(self):
|
|
self._populate_cache(self.idl.tables[vswitch_idl.OVSREC_TABLE_BRIDGE])
|
|
|
|
@staticmethod
|
|
def port_is_fake_bridge(ovsrec_port):
|
|
tag = ovsrec_port.tag
|
|
if isinstance(tag, list):
|
|
if len(tag) == 0:
|
|
tag = 0
|
|
else:
|
|
tag = tag[0]
|
|
return ovsrec_port.fake_bridge and 0 <= tag <= 4095
|
|
|
|
def _populate_cache(self, ovsrec_bridges):
|
|
if self.cache_valid:
|
|
return
|
|
self.cache_valid = True
|
|
|
|
bridges = set()
|
|
ports = set()
|
|
for ovsrec_bridge in ovsrec_bridges.rows.values():
|
|
name = ovsrec_bridge.name
|
|
if name in bridges:
|
|
LOG.warning('%s: database contains duplicate bridge name',
|
|
name)
|
|
bridges.add(name)
|
|
vsctl_bridge = self.add_bridge_to_cache(ovsrec_bridge, name,
|
|
None, 0)
|
|
if not vsctl_bridge:
|
|
continue
|
|
for ovsrec_port in ovsrec_bridge.ports:
|
|
port_name = ovsrec_port.name
|
|
if port_name in ports:
|
|
# Duplicate ovsrec_port name.
|
|
# (We will warn about that later.)
|
|
continue
|
|
ports.add(port_name)
|
|
if (self.port_is_fake_bridge(ovsrec_port) and
|
|
port_name not in bridges):
|
|
bridges.add(port_name)
|
|
self.add_bridge_to_cache(None, port_name, vsctl_bridge,
|
|
ovsrec_port.tag)
|
|
|
|
bridges = set()
|
|
for ovsrec_bridge in ovsrec_bridges.rows.values():
|
|
name = ovsrec_bridge.name
|
|
if name in bridges:
|
|
continue
|
|
bridges.add(name)
|
|
vsctl_bridge = self.bridges[name]
|
|
for ovsrec_port in ovsrec_bridge.ports:
|
|
port_name = ovsrec_port.name
|
|
vsctl_port = self.ports.get(port_name)
|
|
if vsctl_port:
|
|
if ovsrec_port == vsctl_port.port_cfg:
|
|
LOG.warning('%s: vsctl_port is in multiple bridges '
|
|
'(%s and %s)',
|
|
port_name, vsctl_bridge.name,
|
|
vsctl_port.br.name)
|
|
else:
|
|
LOG.error('%s: database contains duplicate '
|
|
'vsctl_port name',
|
|
ovsrec_port.name)
|
|
continue
|
|
|
|
if (self.port_is_fake_bridge(ovsrec_port) and
|
|
port_name in bridges):
|
|
continue
|
|
|
|
# LOG.debug('ovsrec_port %s %s %s',
|
|
# ovsrec_port, ovsrec_port._data, ovsrec_port.tag)
|
|
vsctl_port = self.add_port_to_cache(vsctl_bridge, ovsrec_port)
|
|
# LOG.debug('vsctl_port %s', vsctl_port)
|
|
for ovsrec_iface in ovsrec_port.interfaces:
|
|
iface = self.ifaces.get(ovsrec_iface.name)
|
|
if iface:
|
|
if ovsrec_iface == iface.iface_cfg:
|
|
LOG.warning(
|
|
'%s: interface is in multiple ports '
|
|
'(%s and %s)',
|
|
ovsrec_iface.name,
|
|
iface.port().port_cfg.name,
|
|
vsctl_port.port_cfg.name)
|
|
else:
|
|
LOG.error(
|
|
'%s: database contains duplicate interface '
|
|
'name',
|
|
ovsrec_iface.name)
|
|
continue
|
|
self.add_iface_to_cache(vsctl_port, ovsrec_iface)
|
|
ovsrec_qos = ovsrec_port.qos
|
|
vsctl_qos = self.add_qos_to_cache(vsctl_port, ovsrec_qos)
|
|
if len(ovsrec_qos):
|
|
for ovsrec_queue in ovsrec_qos[0].queues:
|
|
self.add_queue_to_cache(vsctl_qos, ovsrec_queue)
|
|
|
|
def check_conflicts(self, name, msg):
|
|
self.verify_ports()
|
|
if name in self.bridges:
|
|
vsctl_fatal('%s because a bridge named %s already exists' %
|
|
(msg, name))
|
|
if name in self.ports:
|
|
vsctl_fatal('%s because a port named %s already exists on '
|
|
'bridge %s' %
|
|
(msg, name, self.ports[name].bridge().name))
|
|
if name in self.ifaces:
|
|
vsctl_fatal('%s because an interface named %s already '
|
|
'exists on bridge %s' %
|
|
(msg, name, self.ifaces[name].port().bridge().name))
|
|
|
|
def find_bridge(self, name, must_exist):
|
|
assert self.cache_valid
|
|
vsctl_bridge = self.bridges.get(name)
|
|
if must_exist and not vsctl_bridge:
|
|
vsctl_fatal('no bridge named %s' % name)
|
|
self.verify_bridges()
|
|
return vsctl_bridge
|
|
|
|
def find_real_bridge(self, name, must_exist):
|
|
vsctl_bridge = self.find_bridge(name, must_exist)
|
|
if vsctl_bridge and vsctl_bridge.parent:
|
|
vsctl_fatal('%s is a fake bridge' % name)
|
|
return vsctl_bridge
|
|
|
|
def find_bridge_by_id(self, datapath_id, must_exist):
|
|
assert self.cache_valid
|
|
for vsctl_bridge in self.bridges.values():
|
|
if vsctl_bridge.br_cfg.datapath_id[0].strip('"') == datapath_id:
|
|
self.verify_bridges()
|
|
return vsctl_bridge
|
|
|
|
if must_exist:
|
|
vsctl_fatal('no bridge id %s' % datapath_id)
|
|
return None
|
|
|
|
def find_port(self, name, must_exist):
|
|
assert self.cache_valid
|
|
vsctl_port = self.ports.get(name)
|
|
if vsctl_port and name == vsctl_port.bridge().name:
|
|
vsctl_port = None
|
|
if must_exist and not vsctl_port:
|
|
vsctl_fatal('no vsctl_port named %s' % name)
|
|
return vsctl_port
|
|
|
|
def find_iface(self, name, must_exist):
|
|
assert self.cache_valid
|
|
vsctl_iface = self.ifaces.get(name)
|
|
if vsctl_iface and name == vsctl_iface.port().bridge().name:
|
|
vsctl_iface = None
|
|
if must_exist and not vsctl_iface:
|
|
vsctl_fatal('no interface named %s' % name)
|
|
self.verify_ports()
|
|
return vsctl_iface
|
|
|
|
def set_qos(self, vsctl_port, type, max_rate):
|
|
qos = vsctl_port.qos.qos_cfg
|
|
if not len(qos):
|
|
ovsrec_qos = self.txn.insert(
|
|
self.txn.idl.tables[vswitch_idl.OVSREC_TABLE_QOS])
|
|
vsctl_port.port_cfg.qos = [ovsrec_qos]
|
|
else:
|
|
ovsrec_qos = qos[0]
|
|
ovsrec_qos.type = type
|
|
if max_rate is not None:
|
|
value_json = ['map', [['max-rate', max_rate]]]
|
|
self.set_column(ovsrec_qos, 'other_config', value_json)
|
|
self.add_qos_to_cache(vsctl_port, [ovsrec_qos])
|
|
return ovsrec_qos
|
|
|
|
def set_queue(self, vsctl_qos, max_rate, min_rate,
|
|
queue_id):
|
|
|
|
ovsrec_qos = vsctl_qos.qos_cfg[0]
|
|
try:
|
|
ovsrec_queue = ovsrec_qos.queues[queue_id]
|
|
except (AttributeError, KeyError):
|
|
ovsrec_queue = self.txn.insert(
|
|
self.txn.idl.tables[vswitch_idl.OVSREC_TABLE_QUEUE])
|
|
if max_rate is not None:
|
|
value_json = ['map', [['max-rate', max_rate]]]
|
|
self.add_column(ovsrec_queue, 'other_config', value_json)
|
|
if min_rate is not None:
|
|
value_json = ['map', [['min-rate', min_rate]]]
|
|
self.add_column(ovsrec_queue, 'other_config', value_json)
|
|
value_json = ['map', [[queue_id, ['uuid', str(ovsrec_queue.uuid)]]]]
|
|
self.add_column(ovsrec_qos, 'queues', value_json)
|
|
self.add_queue_to_cache(vsctl_qos, ovsrec_queue)
|
|
return ovsrec_queue
|
|
|
|
@staticmethod
|
|
def _column_set(ovsrec_row, column, ovsrec_value):
|
|
# need to trigger Row.__setattr__()
|
|
setattr(ovsrec_row, column, ovsrec_value)
|
|
|
|
@staticmethod
|
|
def _column_insert(ovsrec_row, column, ovsrec_add):
|
|
value = getattr(ovsrec_row, column)
|
|
value.append(ovsrec_add)
|
|
VSCtlContext._column_set(ovsrec_row, column, value)
|
|
|
|
@staticmethod
|
|
def _column_delete(ovsrec_row, column, ovsrec_del):
|
|
value = getattr(ovsrec_row, column)
|
|
try:
|
|
value.remove(ovsrec_del)
|
|
except ValueError:
|
|
# Datum.to_python() with _uuid_to_row trims down deleted
|
|
# references. If ovsrec_del.delete() is called before
|
|
# _column_delete(), value doesn't include ovsrec_del.
|
|
pass
|
|
|
|
VSCtlContext._column_set(ovsrec_row, column, value)
|
|
|
|
@staticmethod
|
|
def bridge_insert_port(ovsrec_bridge, ovsrec_port):
|
|
VSCtlContext._column_insert(ovsrec_bridge,
|
|
vswitch_idl.OVSREC_BRIDGE_COL_PORTS,
|
|
ovsrec_port)
|
|
|
|
@staticmethod
|
|
def bridge_delete_port(ovsrec_bridge, ovsrec_port):
|
|
VSCtlContext._column_delete(ovsrec_bridge,
|
|
vswitch_idl.OVSREC_BRIDGE_COL_PORTS,
|
|
ovsrec_port)
|
|
|
|
@staticmethod
|
|
def port_delete_qos(ovsrec_port, ovsrec_qos):
|
|
VSCtlContext._column_delete(ovsrec_port,
|
|
vswitch_idl.OVSREC_PORT_COL_QOS,
|
|
ovsrec_qos)
|
|
|
|
def ovs_insert_bridge(self, ovsrec_bridge):
|
|
self._column_insert(self.ovs,
|
|
vswitch_idl.OVSREC_OPEN_VSWITCH_COL_BRIDGES,
|
|
ovsrec_bridge)
|
|
|
|
def ovs_delete_bridge(self, ovsrec_bridge):
|
|
self._column_delete(self.ovs,
|
|
vswitch_idl.OVSREC_OPEN_VSWITCH_COL_BRIDGES,
|
|
ovsrec_bridge)
|
|
|
|
def del_port(self, vsctl_port):
|
|
if vsctl_port.bridge().parent:
|
|
ovsrec_bridge = vsctl_port.bridge().parent.br_cfg
|
|
else:
|
|
ovsrec_bridge = vsctl_port.bridge().br_cfg
|
|
self.bridge_delete_port(ovsrec_bridge, vsctl_port.port_cfg)
|
|
|
|
for vsctl_iface in vsctl_port.ifaces.copy():
|
|
self.del_cached_iface(vsctl_iface)
|
|
self.del_cached_port(vsctl_port)
|
|
|
|
def del_bridge(self, vsctl_bridge):
|
|
for child in vsctl_bridge.children.copy():
|
|
self.del_bridge(child)
|
|
for vsctl_port in vsctl_bridge.ports.copy():
|
|
self.del_port(vsctl_port)
|
|
self.del_cached_bridge(vsctl_bridge)
|
|
|
|
def del_qos(self, vsctl_qos):
|
|
ovsrec_port = vsctl_qos.port().port_cfg
|
|
ovsrec_qos = vsctl_qos.qos_cfg
|
|
if len(ovsrec_qos):
|
|
self.port_delete_qos(ovsrec_port, ovsrec_qos[0])
|
|
self.del_cached_qos(vsctl_qos)
|
|
|
|
def add_port(self, br_name, port_name, may_exist, fake_iface,
|
|
iface_names, settings=None):
|
|
"""
|
|
:type settings: list of (column, value_json)
|
|
where column is str,
|
|
value_json is json that is represented
|
|
by Datum.to_json()
|
|
"""
|
|
settings = settings or []
|
|
|
|
self.populate_cache()
|
|
if may_exist:
|
|
vsctl_port = self.find_port(port_name, False)
|
|
if vsctl_port:
|
|
want_names = set(iface_names)
|
|
have_names = set(ovsrec_iface.name for ovsrec_iface in
|
|
vsctl_port.port_cfg.interfaces)
|
|
if vsctl_port.bridge().name != br_name:
|
|
vsctl_fatal('"%s" but %s is actually attached to '
|
|
'vsctl_bridge %s' %
|
|
(br_name, port_name, vsctl_port.bridge().name))
|
|
if want_names != have_names:
|
|
want_names_string = ','.join(want_names)
|
|
have_names_string = ','.join(have_names)
|
|
vsctl_fatal('"%s" but %s actually has interface(s) %s' %
|
|
(want_names_string,
|
|
port_name, have_names_string))
|
|
return
|
|
self.check_conflicts(port_name,
|
|
'cannot create a port named %s' % port_name)
|
|
for iface_name in iface_names:
|
|
self.check_conflicts(
|
|
iface_name, 'cannot create an interface named %s' % iface_name)
|
|
|
|
vsctl_bridge = self.find_bridge(br_name, True)
|
|
ifaces = []
|
|
for iface_name in iface_names:
|
|
ovsrec_iface = self.txn.insert(
|
|
self.idl.tables[vswitch_idl.OVSREC_TABLE_INTERFACE])
|
|
ovsrec_iface.name = iface_name
|
|
ifaces.append(ovsrec_iface)
|
|
|
|
ovsrec_port = self.txn.insert(
|
|
self.idl.tables[vswitch_idl.OVSREC_TABLE_PORT])
|
|
ovsrec_port.name = port_name
|
|
ovsrec_port.interfaces = ifaces
|
|
ovsrec_port.bond_fake_iface = fake_iface
|
|
|
|
if vsctl_bridge.parent:
|
|
tag = vsctl_bridge.vlan
|
|
ovsrec_port.tag = tag
|
|
for column, value in settings:
|
|
# TODO:XXX self.symtab:
|
|
self.set_column(ovsrec_port, column, value)
|
|
|
|
if vsctl_bridge.parent:
|
|
ovsrec_bridge = vsctl_bridge.parent.br_cfg
|
|
else:
|
|
ovsrec_bridge = vsctl_bridge.br_cfg
|
|
self.bridge_insert_port(ovsrec_bridge, ovsrec_port)
|
|
vsctl_port = self.add_port_to_cache(vsctl_bridge, ovsrec_port)
|
|
for ovsrec_iface in ifaces:
|
|
self.add_iface_to_cache(vsctl_port, ovsrec_iface)
|
|
|
|
def add_bridge(self, br_name, parent_name=None, vlan=0, may_exist=False):
|
|
self.populate_cache()
|
|
if may_exist:
|
|
vsctl_bridge = self.find_bridge(br_name, False)
|
|
if vsctl_bridge:
|
|
if not parent_name:
|
|
if vsctl_bridge.parent:
|
|
vsctl_fatal('"--may-exist add-vsctl_bridge %s" '
|
|
'but %s is a VLAN bridge for VLAN %d' %
|
|
(br_name, br_name, vsctl_bridge.vlan))
|
|
else:
|
|
if not vsctl_bridge.parent:
|
|
vsctl_fatal('"--may-exist add-vsctl_bridge %s %s %d" '
|
|
'but %s is not a VLAN bridge' %
|
|
(br_name, parent_name, vlan, br_name))
|
|
elif vsctl_bridge.parent.name != parent_name:
|
|
vsctl_fatal('"--may-exist add-vsctl_bridge %s %s %d" '
|
|
'but %s has the wrong parent %s' %
|
|
(br_name, parent_name, vlan,
|
|
br_name, vsctl_bridge.parent.name))
|
|
elif vsctl_bridge.vlan != vlan:
|
|
vsctl_fatal('"--may-exist add-vsctl_bridge %s %s %d" '
|
|
'but %s is a VLAN bridge for the wrong '
|
|
'VLAN %d' %
|
|
(br_name, parent_name, vlan, br_name,
|
|
vsctl_bridge.vlan))
|
|
return
|
|
|
|
self.check_conflicts(br_name,
|
|
'cannot create a bridge named %s' % br_name)
|
|
|
|
txn = self.txn
|
|
tables = self.idl.tables
|
|
if not parent_name:
|
|
ovsrec_iface = txn.insert(
|
|
tables[vswitch_idl.OVSREC_TABLE_INTERFACE])
|
|
ovsrec_iface.name = br_name
|
|
ovsrec_iface.type = 'internal'
|
|
|
|
ovsrec_port = txn.insert(tables[vswitch_idl.OVSREC_TABLE_PORT])
|
|
ovsrec_port.name = br_name
|
|
ovsrec_port.interfaces = [ovsrec_iface]
|
|
ovsrec_port.fake_bridge = False
|
|
|
|
ovsrec_bridge = txn.insert(tables[vswitch_idl.OVSREC_TABLE_BRIDGE])
|
|
ovsrec_bridge.name = br_name
|
|
ovsrec_bridge.ports = [ovsrec_port]
|
|
|
|
self.ovs_insert_bridge(ovsrec_bridge)
|
|
else:
|
|
parent = self.find_bridge(parent_name, False)
|
|
if parent and parent.parent:
|
|
vsctl_fatal('cannot create bridge with fake bridge as parent')
|
|
if not parent:
|
|
vsctl_fatal('parent bridge %s does not exist' % parent_name)
|
|
|
|
ovsrec_iface = txn.insert(
|
|
tables[vswitch_idl.OVSREC_TABLE_INTERFACE])
|
|
ovsrec_iface.name = br_name
|
|
ovsrec_iface.type = 'internal'
|
|
|
|
ovsrec_port = txn.insert(tables[vswitch_idl.OVSREC_TABLE_PORT])
|
|
ovsrec_port.name = br_name
|
|
ovsrec_port.interfaces = [ovsrec_iface]
|
|
ovsrec_port.fake_bridge = True
|
|
ovsrec_port.tag = vlan
|
|
|
|
self.bridge_insert_port(parent.br_cfg, ovsrec_port)
|
|
|
|
self.invalidate_cache()
|
|
|
|
@staticmethod
|
|
def parse_column_key(setting_string):
|
|
"""
|
|
Parses 'setting_string' as str formatted in <column>[:<key>]
|
|
and returns str type 'column' and 'key'
|
|
"""
|
|
if ':' in setting_string:
|
|
# splits <column>:<key> into <column> and <key>
|
|
column, key = setting_string.split(':', 1)
|
|
else:
|
|
# stores <column> and <value>=None
|
|
column = setting_string
|
|
key = None
|
|
|
|
return column, key
|
|
|
|
@staticmethod
|
|
def parse_column_key_value(table_schema, setting_string):
|
|
"""
|
|
Parses 'setting_string' as str formatted in <column>[:<key>]=<value>
|
|
and returns str type 'column' and json formatted 'value'
|
|
"""
|
|
if ':' in setting_string:
|
|
# splits <column>:<key>=<value> into <column> and <key>=<value>
|
|
column, value = setting_string.split(':', 1)
|
|
elif '=' in setting_string:
|
|
# splits <column>=<value> into <column> and <value>
|
|
column, value = setting_string.split('=', 1)
|
|
else:
|
|
# stores <column> and <value>=None
|
|
column = setting_string
|
|
value = None
|
|
|
|
if value is not None:
|
|
type_ = table_schema.columns[column].type
|
|
value = datum_from_string(type_, value)
|
|
|
|
return column, value
|
|
|
|
def get_column(self, ovsrec_row, column, key=None, if_exists=False):
|
|
value = getattr(ovsrec_row, column, None)
|
|
if isinstance(value, dict) and key is not None:
|
|
value = value.get(key, None)
|
|
column = '%s:%s' % (column, key)
|
|
|
|
if value is None:
|
|
if if_exists:
|
|
return None
|
|
vsctl_fatal('%s does not contain a column whose name matches "%s"'
|
|
% (ovsrec_row._table.name, column))
|
|
|
|
return value
|
|
|
|
def _pre_mod_column(self, ovsrec_row, column, value_json):
|
|
if column not in ovsrec_row._table.columns:
|
|
vsctl_fatal('%s does not contain a column whose name matches "%s"'
|
|
% (ovsrec_row._table.name, column))
|
|
|
|
column_schema = ovsrec_row._table.columns[column]
|
|
datum = ovs.db.data.Datum.from_json(
|
|
column_schema.type, value_json, self.symtab)
|
|
return datum.to_python(ovs.db.idl._uuid_to_row)
|
|
|
|
def set_column(self, ovsrec_row, column, value_json):
|
|
column_schema = ovsrec_row._table.columns[column]
|
|
datum = self._pre_mod_column(ovsrec_row, column, value_json)
|
|
|
|
if column_schema.type.is_map():
|
|
values = getattr(ovsrec_row, column, {})
|
|
values.update(datum)
|
|
else:
|
|
values = datum
|
|
|
|
setattr(ovsrec_row, column, values)
|
|
|
|
def add_column(self, ovsrec_row, column, value_json):
|
|
column_schema = ovsrec_row._table.columns[column]
|
|
datum = self._pre_mod_column(ovsrec_row, column, value_json)
|
|
|
|
if column_schema.type.is_map():
|
|
values = getattr(ovsrec_row, column, {})
|
|
values.update(datum)
|
|
elif column_schema.type.is_set():
|
|
values = getattr(ovsrec_row, column, [])
|
|
values.extend(datum)
|
|
else:
|
|
values = datum
|
|
|
|
setattr(ovsrec_row, column, values)
|
|
|
|
def remove_column(self, ovsrec_row, column, value_json):
|
|
column_schema = ovsrec_row._table.columns[column]
|
|
datum = self._pre_mod_column(ovsrec_row, column, value_json)
|
|
|
|
if column_schema.type.is_map():
|
|
values = getattr(ovsrec_row, column, {})
|
|
for datum_key, datum_value in datum.items():
|
|
v = values.get(datum_key, None)
|
|
if v == datum_value:
|
|
values.pop(datum_key)
|
|
setattr(ovsrec_row, column, values)
|
|
elif column_schema.type.is_set():
|
|
values = getattr(ovsrec_row, column, [])
|
|
for d in datum:
|
|
if d in values:
|
|
values.remove(d)
|
|
setattr(ovsrec_row, column, values)
|
|
else:
|
|
values = getattr(ovsrec_row, column, None)
|
|
default = ovs.db.data.Datum.default(column_schema.type)
|
|
default = default.to_python(ovs.db.idl._uuid_to_row).to_json()
|
|
if values == datum:
|
|
setattr(ovsrec_row, column, default)
|
|
|
|
def _get_row_by_id(self, table_name, vsctl_row_id, record_id):
|
|
if not vsctl_row_id.table:
|
|
return None
|
|
|
|
if not vsctl_row_id.name_column:
|
|
if record_id != '.':
|
|
return None
|
|
values = list(self.idl.tables[vsctl_row_id.table].rows.values())
|
|
if not values or len(values) > 2:
|
|
return None
|
|
referrer = values[0]
|
|
else:
|
|
referrer = None
|
|
for ovsrec_row in self.idl.tables[
|
|
vsctl_row_id.table].rows.values():
|
|
name = getattr(ovsrec_row, vsctl_row_id.name_column)
|
|
assert isinstance(name, (list, str, six.text_type))
|
|
if not isinstance(name, list) and name == record_id:
|
|
if referrer:
|
|
vsctl_fatal('multiple rows in %s match "%s"' %
|
|
(table_name, record_id))
|
|
referrer = ovsrec_row
|
|
|
|
if not referrer:
|
|
return None
|
|
|
|
final = None
|
|
if vsctl_row_id.uuid_column:
|
|
referrer.verify(vsctl_row_id.uuid_column)
|
|
uuid = getattr(referrer, vsctl_row_id.uuid_column)
|
|
|
|
uuid_ = referrer._data[vsctl_row_id.uuid_column]
|
|
assert uuid_.type.key.type == ovs.db.types.UuidType
|
|
assert uuid_.type.value is None
|
|
assert isinstance(uuid, list)
|
|
|
|
if len(uuid) == 1:
|
|
final = uuid[0]
|
|
else:
|
|
final = referrer
|
|
|
|
return final
|
|
|
|
def get_row(self, vsctl_table, record_id):
|
|
table_name = vsctl_table.table_name
|
|
if ovsuuid.is_valid_string(record_id):
|
|
uuid = ovsuuid.from_string(record_id)
|
|
return self.idl.tables[table_name].rows.get(uuid)
|
|
else:
|
|
for vsctl_row_id in vsctl_table.row_ids:
|
|
ovsrec_row = self._get_row_by_id(table_name, vsctl_row_id,
|
|
record_id)
|
|
if ovsrec_row:
|
|
return ovsrec_row
|
|
|
|
return None
|
|
|
|
def must_get_row(self, vsctl_table, record_id):
|
|
ovsrec_row = self.get_row(vsctl_table, record_id)
|
|
if not ovsrec_row:
|
|
vsctl_fatal('no row "%s" in table %s' % (record_id,
|
|
vsctl_table.table_name))
|
|
return ovsrec_row
|
|
|
|
|
|
class _CmdShowTable(object):
|
|
|
|
def __init__(self, table, name_column, columns, recurse):
|
|
super(_CmdShowTable, self).__init__()
|
|
self.table = table
|
|
self.name_column = name_column
|
|
self.columns = columns
|
|
self.recurse = recurse
|
|
|
|
|
|
class _VSCtlRowID(object):
|
|
|
|
def __init__(self, table, name_column, uuid_column):
|
|
super(_VSCtlRowID, self).__init__()
|
|
self.table = table
|
|
self.name_column = name_column
|
|
self.uuid_column = uuid_column
|
|
|
|
|
|
class _VSCtlTable(object):
|
|
|
|
def __init__(self, table_name, vsctl_row_id_list):
|
|
super(_VSCtlTable, self).__init__()
|
|
self.table_name = table_name
|
|
self.row_ids = vsctl_row_id_list
|
|
|
|
|
|
class VSCtlCommand(StringifyMixin):
|
|
"""
|
|
Class to describe artgumens similar to those of ``ovs-vsctl`` command.
|
|
|
|
``command`` specifies the command of ``ovs-vsctl``.
|
|
|
|
``args`` specifies a list or tuple of arguments for the given command.
|
|
|
|
``options`` specifies a list or tuple of options for the given command.
|
|
Please note that NOT all options of ``ovs-vsctl`` are supported.
|
|
For example, ``--id`` option is not yet supported.
|
|
This class supports the followings.
|
|
|
|
================= =========================================================
|
|
Option Description
|
|
================= =========================================================
|
|
``--may-exist`` Does nothing when the given port already exists.
|
|
The supported commands are ``add-port`` and
|
|
``add-bond``.
|
|
``--fake-iface`` Creates a port as a fake interface.
|
|
The supported command is ``add-bond``.
|
|
``--must-exist`` Raises exception if the given port does not exist.
|
|
The supported command is ``del-port``.
|
|
``--with-iface`` Takes effect to the interface which has the same name.
|
|
The supported command is ``del-port``.
|
|
``--if-exists`` Ignores exception when not found.
|
|
The supported command is ``get``.
|
|
================= =========================================================
|
|
"""
|
|
|
|
def __init__(self, command, args=None, options=None):
|
|
super(VSCtlCommand, self).__init__()
|
|
self.command = command
|
|
self.args = args or []
|
|
self.options = options or []
|
|
|
|
# Data modified by commands
|
|
self.result = None
|
|
|
|
# internally used by VSCtl
|
|
self._prerequisite = None
|
|
self._run = None
|
|
|
|
def has_option(self, option):
|
|
return option in self.options
|
|
|
|
|
|
class VSCtl(object):
|
|
"""
|
|
A class to describe an Open vSwitch instance.
|
|
|
|
``remote`` specifies the address of the OVS instance.
|
|
:py:mod:`ryu.lib.ovs.vsctl.valid_ovsdb_addr` is a convenient function to
|
|
validate this address.
|
|
"""
|
|
|
|
def _reset(self):
|
|
self.schema_helper = None
|
|
self.ovs = None
|
|
self.txn = None
|
|
self.wait_for_reload = True
|
|
self.dry_run = False
|
|
|
|
def __init__(self, remote):
|
|
super(VSCtl, self).__init__()
|
|
self.remote = remote
|
|
|
|
self.schema_json = None
|
|
self.schema = None
|
|
self.schema_helper = None
|
|
self.ovs = None
|
|
self.txn = None
|
|
self.wait_for_reload = True
|
|
self.dry_run = False
|
|
|
|
def _rpc_get_schema_json(self, database):
|
|
LOG.debug('remote %s', self.remote)
|
|
error, stream_ = stream.Stream.open_block(
|
|
stream.Stream.open(self.remote))
|
|
if error:
|
|
vsctl_fatal('error %s' % os.strerror(error))
|
|
rpc = jsonrpc.Connection(stream_)
|
|
request = jsonrpc.Message.create_request('get_schema', [database])
|
|
error, reply = rpc.transact_block(request)
|
|
rpc.close()
|
|
|
|
if error:
|
|
vsctl_fatal(os.strerror(error))
|
|
elif reply.error:
|
|
vsctl_fatal('error %s' % reply.error)
|
|
return reply.result
|
|
|
|
def _init_schema_helper(self):
|
|
if self.schema_json is None:
|
|
self.schema_json = self._rpc_get_schema_json(
|
|
vswitch_idl.OVSREC_DB_NAME)
|
|
schema_helper = idl.SchemaHelper(None, self.schema_json)
|
|
schema_helper.register_all()
|
|
self.schema = schema_helper.get_idl_schema()
|
|
# LOG.debug('schema_json %s', schema_json)
|
|
self.schema_helper = idl.SchemaHelper(None, self.schema_json)
|
|
|
|
@staticmethod
|
|
def _idl_block(idl_):
|
|
poller = ovs.poller.Poller()
|
|
idl_.wait(poller)
|
|
poller.block()
|
|
|
|
@staticmethod
|
|
def _idl_wait(idl_, seqno):
|
|
while idl_.change_seqno == seqno and not idl_.run():
|
|
VSCtl._idl_block(idl_)
|
|
|
|
def _run_prerequisites(self, commands):
|
|
schema_helper = self.schema_helper
|
|
schema_helper.register_table(vswitch_idl.OVSREC_TABLE_OPEN_VSWITCH)
|
|
if self.wait_for_reload:
|
|
# LOG.debug('schema_helper._tables %s', schema_helper._tables)
|
|
schema_helper.register_columns(
|
|
vswitch_idl.OVSREC_TABLE_OPEN_VSWITCH,
|
|
[vswitch_idl.OVSREC_OPEN_VSWITCH_COL_CUR_CFG])
|
|
|
|
for command in commands:
|
|
if not command._prerequisite:
|
|
continue
|
|
ctx = VSCtlContext(None, None, None)
|
|
command._prerequisite(ctx, command)
|
|
ctx.done()
|
|
|
|
def _do_vsctl(self, idl_, commands):
|
|
self.txn = idl.Transaction(idl_)
|
|
if self.dry_run:
|
|
self.txn.dry_run = True
|
|
|
|
self.txn.add_comment('ovs-vsctl') # TODO:XXX add operation name. args
|
|
ovs_rows = idl_.tables[vswitch_idl.OVSREC_TABLE_OPEN_VSWITCH].rows
|
|
if ovs_rows:
|
|
ovs_ = list(ovs_rows.values())[0]
|
|
else:
|
|
# XXX add verification that table is empty
|
|
ovs_ = self.txn.insert(
|
|
idl_.tables[vswitch_idl.OVSREC_TABLE_OPEN_VSWITCH])
|
|
|
|
if self.wait_for_reload:
|
|
ovs_.increment(vswitch_idl.OVSREC_OPEN_VSWITCH_COL_NEXT_CFG)
|
|
|
|
# TODO:XXX
|
|
# symtab = ovsdb_symbol_table_create()
|
|
ctx = VSCtlContext(idl_, self.txn, ovs_)
|
|
for command in commands:
|
|
if not command._run:
|
|
continue
|
|
command._run(ctx, command)
|
|
if ctx.try_again:
|
|
return False
|
|
LOG.debug('result:\n%s', [command.result for command in commands])
|
|
ctx.done()
|
|
|
|
# TODO:XXX check if created symbols are really created, referenced.
|
|
|
|
status = self.txn.commit_block()
|
|
next_cfg = 0
|
|
if self.wait_for_reload and status == idl.Transaction.SUCCESS:
|
|
next_cfg = self.txn.get_increment_new_value()
|
|
|
|
# TODO:XXX
|
|
# if status in (idl.Transaction.UNCHANGED, idl.Transaction.SUCCESS):
|
|
# for command in commands:
|
|
# if not command.post_func:
|
|
# continue
|
|
# ctx = VSCtlContext(idl_, txn, self.ovs)
|
|
# command.post_func(ctx)
|
|
# ctx.done()
|
|
|
|
txn_ = self.txn
|
|
self.txn = None
|
|
|
|
if status in (idl.Transaction.UNCOMMITTED, idl.Transaction.INCOMPLETE):
|
|
not_reached()
|
|
elif status == idl.Transaction.ABORTED:
|
|
vsctl_fatal('transaction aborted')
|
|
elif status == idl.Transaction.UNCHANGED:
|
|
LOG.debug('unchanged')
|
|
elif status == idl.Transaction.SUCCESS:
|
|
LOG.debug('success')
|
|
elif status == idl.Transaction.TRY_AGAIN:
|
|
return False
|
|
elif status == idl.Transaction.ERROR:
|
|
vsctl_fatal('transaction error: %s' % txn_.get_error())
|
|
elif status == idl.Transaction.NOT_LOCKED:
|
|
vsctl_fatal('database not locked')
|
|
else:
|
|
not_reached()
|
|
|
|
if self.wait_for_reload and status != idl.Transaction.UNCHANGED:
|
|
while True:
|
|
idl_.run()
|
|
if ovs_.cur_cfg >= next_cfg:
|
|
break
|
|
self._idl_block(idl_)
|
|
|
|
return True
|
|
|
|
def _do_main(self, commands):
|
|
"""
|
|
:type commands: list of VSCtlCommand
|
|
"""
|
|
self._reset()
|
|
self._init_schema_helper()
|
|
self._run_prerequisites(commands)
|
|
|
|
idl_ = idl.Idl(self.remote, self.schema_helper)
|
|
seqno = idl_.change_seqno
|
|
while True:
|
|
self._idl_wait(idl_, seqno)
|
|
|
|
seqno = idl_.change_seqno
|
|
if self._do_vsctl(idl_, commands):
|
|
break
|
|
|
|
if self.txn:
|
|
self.txn.abort()
|
|
self.txn = None
|
|
# TODO:XXX
|
|
# ovsdb_symbol_table_destroy(symtab)
|
|
|
|
idl_.close()
|
|
|
|
def _run_command(self, commands):
|
|
"""
|
|
:type commands: list of VSCtlCommand
|
|
"""
|
|
all_commands = {
|
|
# Open vSwitch commands.
|
|
'init': (None, self._cmd_init),
|
|
'show': (self._pre_cmd_show, self._cmd_show),
|
|
# 'emer-reset':
|
|
|
|
# Bridge commands.
|
|
'add-br': (self._pre_add_br, self._cmd_add_br),
|
|
'del-br': (self._pre_get_info, self._cmd_del_br),
|
|
'list-br': (self._pre_get_info, self._cmd_list_br),
|
|
'br-exists': (self._pre_get_info, self._cmd_br_exists),
|
|
'br-to-vlan': (self._pre_get_info, self._cmd_br_to_vlan),
|
|
'br-to-parent': (self._pre_get_info, self._cmd_br_to_parent),
|
|
'br-set-external-id': (self._pre_cmd_br_set_external_id,
|
|
self._cmd_br_set_external_id),
|
|
'br-get-external-id': (self._pre_cmd_br_get_external_id,
|
|
self._cmd_br_get_external_id),
|
|
|
|
# Port. commands
|
|
'list-ports': (self._pre_get_info, self._cmd_list_ports),
|
|
'add-port': (self._pre_cmd_add_port, self._cmd_add_port),
|
|
'add-bond': (self._pre_cmd_add_bond, self._cmd_add_bond),
|
|
'del-port': (self._pre_get_info, self._cmd_del_port),
|
|
'port-to-br': (self._pre_get_info, self._cmd_port_to_br),
|
|
|
|
# Interface commands.
|
|
'list-ifaces': (self._pre_get_info, self._cmd_list_ifaces),
|
|
'iface-to-br': (self._pre_get_info, self._cmd_iface_to_br),
|
|
|
|
# Controller commands.
|
|
'get-controller': (self._pre_controller, self._cmd_get_controller),
|
|
'del-controller': (self._pre_controller, self._cmd_del_controller),
|
|
'set-controller': (self._pre_controller, self._cmd_set_controller),
|
|
'get-fail-mode': (self._pre_fail_mode, self._cmd_get_fail_mode),
|
|
'del-fail-mode': (self._pre_fail_mode, self._cmd_del_fail_mode),
|
|
'set-fail-mode': (self._pre_fail_mode, self._cmd_set_fail_mode),
|
|
|
|
# Manager commands.
|
|
# 'get-manager':
|
|
# 'del-manager':
|
|
# 'set-manager':
|
|
|
|
# SSL commands.
|
|
# 'get-ssl':
|
|
# 'del-ssl':
|
|
# 'set-ssl':
|
|
|
|
# Auto Attach commands.
|
|
# 'add-aa-mapping':
|
|
# 'del-aa-mapping':
|
|
# 'get-aa-mapping':
|
|
|
|
# Switch commands.
|
|
# 'emer-reset':
|
|
|
|
# Database commands.
|
|
'list': (self._pre_cmd_list, self._cmd_list),
|
|
'find': (self._pre_cmd_find, self._cmd_find),
|
|
'get': (self._pre_cmd_get, self._cmd_get),
|
|
'set': (self._pre_cmd_set, self._cmd_set),
|
|
'add': (self._pre_cmd_add, self._cmd_add),
|
|
'remove': (self._pre_cmd_remove, self._cmd_remove),
|
|
'clear': (self._pre_cmd_clear, self._cmd_clear),
|
|
# 'create':
|
|
# 'destroy':
|
|
# 'wait-until':
|
|
|
|
# Utility commands. (No corresponding command in ovs-vsctl)
|
|
'set-qos': (self._pre_cmd_set_qos, self._cmd_set_qos),
|
|
'set-queue': (self._pre_cmd_set_queue, self._cmd_set_queue),
|
|
'del-qos': (self._pre_get_info, self._cmd_del_qos),
|
|
# for quantum_adapter
|
|
'list-ifaces-verbose': (self._pre_cmd_list_ifaces_verbose,
|
|
self._cmd_list_ifaces_verbose),
|
|
}
|
|
|
|
for command in commands:
|
|
funcs = all_commands[command.command]
|
|
command._prerequisite, command._run = funcs
|
|
self._do_main(commands)
|
|
|
|
def run_command(self, commands, timeout_sec=None, exception=None):
|
|
"""
|
|
Executes the given commands and sends OVSDB messages.
|
|
|
|
``commands`` must be a list of
|
|
:py:mod:`ryu.lib.ovs.vsctl.VSCtlCommand`.
|
|
|
|
If ``timeout_sec`` is specified, raises exception after the given
|
|
timeout [sec]. Additionally, if ``exception`` is specified, this
|
|
function will wraps exception using the given exception class.
|
|
|
|
Retruns ``None`` but fills ``result`` attribute for each command
|
|
instance.
|
|
"""
|
|
if timeout_sec is None:
|
|
self._run_command(commands)
|
|
else:
|
|
with hub.Timeout(timeout_sec, exception):
|
|
self._run_command(commands)
|
|
|
|
# Open vSwitch commands:
|
|
|
|
def _cmd_init(self, _ctx, _command):
|
|
# nothing. Just check connection to ovsdb
|
|
pass
|
|
|
|
_CMD_SHOW_TABLES = [
|
|
_CmdShowTable(vswitch_idl.OVSREC_TABLE_OPEN_VSWITCH, None,
|
|
[vswitch_idl.OVSREC_OPEN_VSWITCH_COL_MANAGER_OPTIONS,
|
|
vswitch_idl.OVSREC_OPEN_VSWITCH_COL_BRIDGES,
|
|
vswitch_idl.OVSREC_OPEN_VSWITCH_COL_OVS_VERSION],
|
|
False),
|
|
_CmdShowTable(vswitch_idl.OVSREC_TABLE_BRIDGE,
|
|
vswitch_idl.OVSREC_BRIDGE_COL_NAME,
|
|
[vswitch_idl.OVSREC_BRIDGE_COL_CONTROLLER,
|
|
vswitch_idl.OVSREC_BRIDGE_COL_FAIL_MODE,
|
|
vswitch_idl.OVSREC_BRIDGE_COL_PORTS],
|
|
False),
|
|
_CmdShowTable(vswitch_idl.OVSREC_TABLE_PORT,
|
|
vswitch_idl.OVSREC_PORT_COL_NAME,
|
|
[vswitch_idl.OVSREC_PORT_COL_TAG,
|
|
vswitch_idl.OVSREC_PORT_COL_TRUNKS,
|
|
vswitch_idl.OVSREC_PORT_COL_INTERFACES],
|
|
False),
|
|
_CmdShowTable(vswitch_idl.OVSREC_TABLE_INTERFACE,
|
|
vswitch_idl.OVSREC_INTERFACE_COL_NAME,
|
|
[vswitch_idl.OVSREC_INTERFACE_COL_TYPE,
|
|
vswitch_idl.OVSREC_INTERFACE_COL_OPTIONS],
|
|
False),
|
|
_CmdShowTable(vswitch_idl.OVSREC_TABLE_CONTROLLER,
|
|
vswitch_idl.OVSREC_CONTROLLER_COL_TARGET,
|
|
[vswitch_idl.OVSREC_CONTROLLER_COL_IS_CONNECTED],
|
|
False),
|
|
_CmdShowTable(vswitch_idl.OVSREC_TABLE_MANAGER,
|
|
vswitch_idl.OVSREC_MANAGER_COL_TARGET,
|
|
[vswitch_idl.OVSREC_MANAGER_COL_IS_CONNECTED],
|
|
False),
|
|
]
|
|
|
|
def _pre_cmd_show(self, _ctx, _command):
|
|
schema_helper = self.schema_helper
|
|
for show in self._CMD_SHOW_TABLES:
|
|
schema_helper.register_table(show.table)
|
|
if show.name_column:
|
|
schema_helper.register_columns(show.table, [show.name_column])
|
|
schema_helper.register_columns(show.table, show.columns)
|
|
|
|
@staticmethod
|
|
def _cmd_show_find_table_by_row(row):
|
|
for show in VSCtl._CMD_SHOW_TABLES:
|
|
if show.table == row._table.name:
|
|
return show
|
|
return None
|
|
|
|
@staticmethod
|
|
def _cmd_show_find_table_by_name(name):
|
|
for show in VSCtl._CMD_SHOW_TABLES:
|
|
if show.table == name:
|
|
return show
|
|
return None
|
|
|
|
@staticmethod
|
|
def _cmd_show_row(ctx, row, level):
|
|
_INDENT_SIZE = 4 # # of spaces per indent
|
|
show = VSCtl._cmd_show_find_table_by_row(row)
|
|
output = ''
|
|
|
|
output += ' ' * level * _INDENT_SIZE
|
|
if show and show.name_column:
|
|
output += '%s ' % show.table
|
|
datum = getattr(row, show.name_column)
|
|
output += datum
|
|
else:
|
|
output += str(row.uuid)
|
|
output += '\n'
|
|
|
|
if not show or show.recurse:
|
|
return
|
|
|
|
show.recurse = True
|
|
for column in show.columns:
|
|
datum = row._data[column]
|
|
key = datum.type.key
|
|
if key.type == ovs.db.types.UuidType and key.ref_table_name:
|
|
ref_show = VSCtl._cmd_show_find_table_by_name(
|
|
key.ref_table_name)
|
|
if ref_show:
|
|
for atom in datum.values:
|
|
ref_row = ctx.idl.tables[ref_show.table].rows.get(
|
|
atom.value)
|
|
if ref_row:
|
|
VSCtl._cmd_show_row(ctx, ref_row, level + 1)
|
|
continue
|
|
|
|
if not datum.is_default():
|
|
output += ' ' * (level + 1) * _INDENT_SIZE
|
|
output += '%s: %s\n' % (column, datum)
|
|
|
|
show.recurse = False
|
|
return output
|
|
|
|
def _cmd_show(self, ctx, command):
|
|
for row in ctx.idl.tables[
|
|
self._CMD_SHOW_TABLES[0].table].rows.values():
|
|
output = self._cmd_show_row(ctx, row, 0)
|
|
command.result = output
|
|
|
|
# Bridge commands:
|
|
|
|
def _pre_get_info(self, _ctx, _command):
|
|
schema_helper = self.schema_helper
|
|
|
|
schema_helper.register_columns(
|
|
vswitch_idl.OVSREC_TABLE_OPEN_VSWITCH,
|
|
[vswitch_idl.OVSREC_OPEN_VSWITCH_COL_BRIDGES])
|
|
schema_helper.register_columns(
|
|
vswitch_idl.OVSREC_TABLE_BRIDGE,
|
|
[vswitch_idl.OVSREC_BRIDGE_COL_NAME,
|
|
vswitch_idl.OVSREC_BRIDGE_COL_CONTROLLER,
|
|
vswitch_idl.OVSREC_BRIDGE_COL_FAIL_MODE,
|
|
vswitch_idl.OVSREC_BRIDGE_COL_PORTS])
|
|
schema_helper.register_columns(
|
|
vswitch_idl.OVSREC_TABLE_PORT,
|
|
[vswitch_idl.OVSREC_PORT_COL_NAME,
|
|
vswitch_idl.OVSREC_PORT_COL_FAKE_BRIDGE,
|
|
vswitch_idl.OVSREC_PORT_COL_TAG,
|
|
vswitch_idl.OVSREC_PORT_COL_INTERFACES,
|
|
vswitch_idl.OVSREC_PORT_COL_QOS])
|
|
schema_helper.register_columns(
|
|
vswitch_idl.OVSREC_TABLE_INTERFACE,
|
|
[vswitch_idl.OVSREC_INTERFACE_COL_NAME])
|
|
schema_helper.register_columns(
|
|
vswitch_idl.OVSREC_TABLE_QOS,
|
|
[vswitch_idl.OVSREC_QOS_COL_QUEUES])
|
|
schema_helper.register_columns(
|
|
vswitch_idl.OVSREC_TABLE_QUEUE,
|
|
[])
|
|
|
|
def _cmd_list_br(self, ctx, command):
|
|
ctx.populate_cache()
|
|
command.result = sorted(ctx.bridges.keys())
|
|
|
|
def _pre_add_br(self, ctx, command):
|
|
self._pre_get_info(ctx, command)
|
|
|
|
schema_helper = self.schema_helper
|
|
schema_helper.register_columns(
|
|
vswitch_idl.OVSREC_TABLE_INTERFACE,
|
|
[vswitch_idl.OVSREC_INTERFACE_COL_TYPE])
|
|
|
|
def _cmd_add_br(self, ctx, command):
|
|
br_name = command.args[0]
|
|
parent_name = None
|
|
vlan = 0
|
|
if len(command.args) == 1:
|
|
pass
|
|
elif len(command.args) == 3:
|
|
parent_name = command.args[1]
|
|
vlan = int(command.args[2])
|
|
if vlan < 0 or vlan > 4095:
|
|
vsctl_fatal("vlan must be between 0 and 4095 %d" % vlan)
|
|
else:
|
|
vsctl_fatal('this command takes exactly 1 or 3 argument')
|
|
|
|
ctx.add_bridge(br_name, parent_name, vlan)
|
|
|
|
def _del_br(self, ctx, br_name, must_exist=False):
|
|
ctx.populate_cache()
|
|
br = ctx.find_bridge(br_name, must_exist)
|
|
if br:
|
|
ctx.del_bridge(br)
|
|
|
|
def _cmd_del_br(self, ctx, command):
|
|
br_name = command.args[0]
|
|
self._del_br(ctx, br_name)
|
|
|
|
def _br_exists(self, ctx, br_name):
|
|
ctx.populate_cache()
|
|
br = ctx.find_bridge(br_name, must_exist=False)
|
|
return br is not None
|
|
|
|
def _cmd_br_exists(self, ctx, command):
|
|
br_name = command.args[0]
|
|
command.result = self._br_exists(ctx, br_name)
|
|
|
|
def _br_to_vlan(self, ctx, br_name):
|
|
ctx.populate_cache()
|
|
br = ctx.find_bridge(br_name, must_exist=True)
|
|
vlan = br.vlan
|
|
if isinstance(vlan, list):
|
|
if len(vlan) == 0:
|
|
vlan = 0
|
|
else:
|
|
vlan = vlan[0]
|
|
return vlan
|
|
|
|
def _cmd_br_to_vlan(self, ctx, command):
|
|
br_name = command.args[0]
|
|
command.result = self._br_to_vlan(ctx, br_name)
|
|
|
|
def _br_to_parent(self, ctx, br_name):
|
|
ctx.populate_cache()
|
|
br = ctx.find_bridge(br_name, must_exist=True)
|
|
return br if br.parent is None else br.parent
|
|
|
|
def _cmd_br_to_parent(self, ctx, command):
|
|
br_name = command.args[0]
|
|
command.result = self._br_to_parent(ctx, br_name)
|
|
|
|
def _pre_cmd_br_set_external_id(self, ctx, _command):
|
|
table_name = vswitch_idl.OVSREC_TABLE_BRIDGE
|
|
columns = [vswitch_idl.OVSREC_BRIDGE_COL_EXTERNAL_IDS]
|
|
self._pre_mod_columns(ctx, table_name, columns)
|
|
|
|
def _br_add_external_id(self, ctx, br_name, key, value):
|
|
table_name = vswitch_idl.OVSREC_TABLE_BRIDGE
|
|
column = vswitch_idl.OVSREC_BRIDGE_COL_EXTERNAL_IDS
|
|
vsctl_table = self._get_table(table_name)
|
|
ovsrec_row = ctx.must_get_row(vsctl_table, br_name)
|
|
|
|
value_json = ['map', [[key, value]]]
|
|
ctx.add_column(ovsrec_row, column, value_json)
|
|
ctx.invalidate_cache()
|
|
|
|
def _br_clear_external_id(self, ctx, br_name, key):
|
|
table_name = vswitch_idl.OVSREC_TABLE_BRIDGE
|
|
column = vswitch_idl.OVSREC_BRIDGE_COL_EXTERNAL_IDS
|
|
vsctl_table = self._get_table(table_name)
|
|
ovsrec_row = ctx.must_get_row(vsctl_table, br_name)
|
|
|
|
values = getattr(ovsrec_row, column, {})
|
|
values.pop(key, None)
|
|
setattr(ovsrec_row, column, values)
|
|
ctx.invalidate_cache()
|
|
|
|
def _cmd_br_set_external_id(self, ctx, command):
|
|
br_name = command.args[0]
|
|
key = command.args[1]
|
|
if len(command.args) > 2:
|
|
self._br_add_external_id(ctx, br_name, key, command.args[2])
|
|
else:
|
|
self._br_clear_external_id(ctx, br_name, key)
|
|
|
|
def _pre_cmd_br_get_external_id(self, ctx, _command):
|
|
table_name = vswitch_idl.OVSREC_TABLE_BRIDGE
|
|
columns = [vswitch_idl.OVSREC_BRIDGE_COL_EXTERNAL_IDS]
|
|
self._pre_get_columns(ctx, table_name, columns)
|
|
|
|
def _br_get_external_id_value(self, ctx, br_name, key):
|
|
external_id = self._br_get_external_id_list(ctx, br_name)
|
|
|
|
return external_id.get(key, None)
|
|
|
|
def _br_get_external_id_list(self, ctx, br_name):
|
|
table_name = vswitch_idl.OVSREC_TABLE_BRIDGE
|
|
column = vswitch_idl.OVSREC_BRIDGE_COL_EXTERNAL_IDS
|
|
vsctl_table = self._get_table(table_name)
|
|
ovsrec_row = ctx.must_get_row(vsctl_table, br_name)
|
|
|
|
return ctx.get_column(ovsrec_row, column)
|
|
|
|
def _cmd_br_get_external_id(self, ctx, command):
|
|
br_name = command.args[0]
|
|
if len(command.args) > 1:
|
|
command.result = self._br_get_external_id_value(ctx, br_name,
|
|
command.args[1])
|
|
else:
|
|
command.result = self._br_get_external_id_list(ctx, br_name)
|
|
|
|
# Port commands:
|
|
|
|
def _list_ports(self, ctx, br_name):
|
|
ctx.populate_cache()
|
|
br = ctx.find_bridge(br_name, True)
|
|
if br.br_cfg:
|
|
br.br_cfg.verify(vswitch_idl.OVSREC_BRIDGE_COL_PORTS)
|
|
else:
|
|
br.parent.br_cfg.verify(vswitch_idl.OVSREC_BRIDGE_COL_PORTS)
|
|
|
|
return [port.port_cfg.name for port in br.ports
|
|
if port.port_cfg.name != br.name]
|
|
|
|
def _cmd_list_ports(self, ctx, command):
|
|
br_name = command.args[0]
|
|
port_names = self._list_ports(ctx, br_name)
|
|
command.result = sorted(port_names)
|
|
|
|
def _pre_add_port(self, _ctx, columns):
|
|
schema_helper = self.schema_helper
|
|
schema_helper.register_columns(
|
|
vswitch_idl.OVSREC_TABLE_PORT,
|
|
[vswitch_idl.OVSREC_PORT_COL_NAME,
|
|
vswitch_idl.OVSREC_PORT_COL_BOND_FAKE_IFACE])
|
|
schema_helper.register_columns(
|
|
vswitch_idl.OVSREC_TABLE_PORT, columns)
|
|
|
|
def _pre_cmd_add_port(self, ctx, command):
|
|
self._pre_get_info(ctx, command)
|
|
|
|
columns = [
|
|
ctx.parse_column_key_value(
|
|
self.schema.tables[vswitch_idl.OVSREC_TABLE_PORT], setting)[0]
|
|
for setting in command.args[2:]]
|
|
|
|
self._pre_add_port(ctx, columns)
|
|
|
|
def _pre_cmd_add_bond(self, ctx, command):
|
|
self._pre_get_info(ctx, command)
|
|
|
|
if len(command.args) < 3:
|
|
vsctl_fatal('this command requires at least 3 arguments')
|
|
|
|
columns = [
|
|
ctx.parse_column_key_value(
|
|
self.schema.tables[vswitch_idl.OVSREC_TABLE_PORT], setting)[0]
|
|
for setting in command.args[3:]]
|
|
|
|
self._pre_add_port(ctx, columns)
|
|
|
|
def _cmd_add_port(self, ctx, command):
|
|
# '--may_exist' is a typo but for backword compatibility
|
|
may_exist = (command.has_option('--may_exist')
|
|
or command.has_option('--may-exist'))
|
|
|
|
br_name = command.args[0]
|
|
port_name = command.args[1]
|
|
iface_names = [command.args[1]]
|
|
settings = [
|
|
ctx.parse_column_key_value(
|
|
self.schema.tables[vswitch_idl.OVSREC_TABLE_PORT], setting)
|
|
for setting in command.args[2:]]
|
|
|
|
ctx.add_port(br_name, port_name, may_exist,
|
|
False, iface_names, settings)
|
|
|
|
def _cmd_add_bond(self, ctx, command):
|
|
# '--may_exist' is a typo but for backword compatibility
|
|
may_exist = (command.has_option('--may_exist')
|
|
or command.has_option('--may-exist'))
|
|
fake_iface = command.has_option('--fake-iface')
|
|
|
|
br_name = command.args[0]
|
|
port_name = command.args[1]
|
|
iface_names = list(command.args[2])
|
|
settings = [
|
|
ctx.parse_column_key_value(
|
|
self.schema.tables[vswitch_idl.OVSREC_TABLE_PORT], setting)
|
|
for setting in command.args[3:]]
|
|
|
|
ctx.add_port(br_name, port_name, may_exist, fake_iface,
|
|
iface_names, settings)
|
|
|
|
def _del_port(self, ctx, br_name=None, target=None,
|
|
must_exist=False, with_iface=False):
|
|
assert target is not None
|
|
|
|
ctx.populate_cache()
|
|
if not with_iface:
|
|
vsctl_port = ctx.find_port(target, must_exist)
|
|
else:
|
|
vsctl_port = ctx.find_port(target, False)
|
|
if not vsctl_port:
|
|
vsctl_iface = ctx.find_iface(target, False)
|
|
if vsctl_iface:
|
|
vsctl_port = vsctl_iface.port()
|
|
if must_exist and not vsctl_port:
|
|
vsctl_fatal('no port or interface named %s' % target)
|
|
|
|
if not vsctl_port:
|
|
return
|
|
if not br_name:
|
|
vsctl_bridge = ctx.find_bridge(br_name, True)
|
|
if vsctl_port.bridge() != vsctl_bridge:
|
|
if vsctl_port.bridge().parent == vsctl_bridge:
|
|
vsctl_fatal('bridge %s does not have a port %s (although '
|
|
'its parent bridge %s does)' %
|
|
(br_name, target, vsctl_bridge.parent.name))
|
|
else:
|
|
vsctl_fatal('bridge %s does not have a port %s' %
|
|
(br_name, target))
|
|
|
|
ctx.del_port(vsctl_port)
|
|
|
|
def _cmd_del_port(self, ctx, command):
|
|
must_exist = command.has_option('--must-exist')
|
|
with_iface = command.has_option('--with-iface')
|
|
target = command.args[-1]
|
|
br_name = command.args[0] if len(command.args) == 2 else None
|
|
self._del_port(ctx, br_name, target, must_exist, with_iface)
|
|
|
|
def _port_to_br(self, ctx, port_name):
|
|
ctx.populate_cache()
|
|
port = ctx.find_port(port_name, True)
|
|
bridge = port.bridge()
|
|
if bridge is None:
|
|
vsctl_fatal('Bridge associated to port "%s" does not exist' %
|
|
port_name)
|
|
|
|
return bridge.name
|
|
|
|
def _cmd_port_to_br(self, ctx, command):
|
|
iface_name = command.args[0]
|
|
command.result = self._iface_to_br(ctx, iface_name)
|
|
|
|
# Interface commands:
|
|
|
|
def _list_ifaces(self, ctx, br_name):
|
|
ctx.populate_cache()
|
|
|
|
br = ctx.find_bridge(br_name, True)
|
|
ctx.verify_ports()
|
|
|
|
iface_names = set()
|
|
for vsctl_port in br.ports:
|
|
for vsctl_iface in vsctl_port.ifaces:
|
|
iface_name = vsctl_iface.iface_cfg.name
|
|
if iface_name != br_name:
|
|
iface_names.add(iface_name)
|
|
return iface_names
|
|
|
|
def _cmd_list_ifaces(self, ctx, command):
|
|
br_name = command.args[0]
|
|
iface_names = self._list_ifaces(ctx, br_name)
|
|
command.result = sorted(iface_names)
|
|
|
|
def _iface_to_br(self, ctx, iface_name):
|
|
ctx.populate_cache()
|
|
iface = ctx.find_iface(iface_name, True)
|
|
port = iface.port()
|
|
if port is None:
|
|
vsctl_fatal('Port associated to iface "%s" does not exist' %
|
|
iface_name)
|
|
bridge = port.bridge()
|
|
if bridge is None:
|
|
vsctl_fatal('Bridge associated to iface "%s" does not exist' %
|
|
iface_name)
|
|
|
|
return bridge.name
|
|
|
|
def _cmd_iface_to_br(self, ctx, command):
|
|
iface_name = command.args[0]
|
|
command.result = self._iface_to_br(ctx, iface_name)
|
|
|
|
# Utility commands for quantum_adapter:
|
|
|
|
def _pre_cmd_list_ifaces_verbose(self, ctx, command):
|
|
self._pre_get_info(ctx, command)
|
|
schema_helper = self.schema_helper
|
|
schema_helper.register_columns(
|
|
vswitch_idl.OVSREC_TABLE_BRIDGE,
|
|
[vswitch_idl.OVSREC_BRIDGE_COL_DATAPATH_ID])
|
|
schema_helper.register_columns(
|
|
vswitch_idl.OVSREC_TABLE_INTERFACE,
|
|
[vswitch_idl.OVSREC_INTERFACE_COL_TYPE,
|
|
vswitch_idl.OVSREC_INTERFACE_COL_NAME,
|
|
vswitch_idl.OVSREC_INTERFACE_COL_EXTERNAL_IDS,
|
|
vswitch_idl.OVSREC_INTERFACE_COL_OPTIONS,
|
|
vswitch_idl.OVSREC_INTERFACE_COL_OFPORT])
|
|
|
|
@staticmethod
|
|
def _iface_to_dict(iface_cfg):
|
|
_ATTRIBUTE = ['name', 'ofport', 'type', 'external_ids', 'options']
|
|
attr = dict((key, getattr(iface_cfg, key)) for key in _ATTRIBUTE)
|
|
|
|
if attr['ofport']:
|
|
attr['ofport'] = attr['ofport'][0]
|
|
return attr
|
|
|
|
def _list_ifaces_verbose(self, ctx, datapath_id, port_name):
|
|
ctx.populate_cache()
|
|
|
|
br = ctx.find_bridge_by_id(datapath_id, True)
|
|
ctx.verify_ports()
|
|
|
|
iface_cfgs = []
|
|
if port_name is None:
|
|
for vsctl_port in br.ports:
|
|
iface_cfgs.extend(self._iface_to_dict(vsctl_iface.iface_cfg)
|
|
for vsctl_iface in vsctl_port.ifaces)
|
|
else:
|
|
# When port is created, ofport column might be None.
|
|
# So try with port name if it happended
|
|
for vsctl_port in br.ports:
|
|
iface_cfgs.extend(
|
|
self._iface_to_dict(vsctl_iface.iface_cfg)
|
|
for vsctl_iface in vsctl_port.ifaces
|
|
if vsctl_iface.iface_cfg.name == port_name)
|
|
|
|
return iface_cfgs
|
|
|
|
def _cmd_list_ifaces_verbose(self, ctx, command):
|
|
datapath_id = command.args[0]
|
|
port_name = None
|
|
if len(command.args) >= 2:
|
|
port_name = command.args[1]
|
|
LOG.debug('command.args %s', command.args)
|
|
iface_cfgs = self._list_ifaces_verbose(ctx, datapath_id, port_name)
|
|
command.result = sorted(iface_cfgs)
|
|
|
|
# Controller commands:
|
|
|
|
def _verify_controllers(self, ovsrec_bridge):
|
|
ovsrec_bridge.verify(vswitch_idl.OVSREC_BRIDGE_COL_CONTROLLER)
|
|
for controller in ovsrec_bridge.controller:
|
|
controller.verify(vswitch_idl.OVSREC_CONTROLLER_COL_TARGET)
|
|
|
|
def _pre_controller(self, ctx, command):
|
|
self._pre_get_info(ctx, command)
|
|
self.schema_helper.register_columns(
|
|
vswitch_idl.OVSREC_TABLE_CONTROLLER,
|
|
[vswitch_idl.OVSREC_CONTROLLER_COL_TARGET])
|
|
|
|
def _get_controller(self, ctx, br_name):
|
|
ctx.populate_cache()
|
|
br = ctx.find_bridge(br_name, True)
|
|
self._verify_controllers(br.br_cfg)
|
|
return set(controller.target for controller in br.br_cfg.controller)
|
|
|
|
def _cmd_get_controller(self, ctx, command):
|
|
br_name = command.args[0]
|
|
controller_names = self._get_controller(ctx, br_name)
|
|
command.result = sorted(controller_names)
|
|
|
|
def _delete_controllers(self, ovsrec_controllers):
|
|
for controller in ovsrec_controllers:
|
|
controller.delete()
|
|
|
|
def _del_controller(self, ctx, br_name):
|
|
ctx.populate_cache()
|
|
br = ctx.find_real_bridge(br_name, True)
|
|
ovsrec_bridge = br.br_cfg
|
|
self._verify_controllers(ovsrec_bridge)
|
|
if ovsrec_bridge.controller:
|
|
self._delete_controllers(ovsrec_bridge.controller)
|
|
ovsrec_bridge.controller = []
|
|
|
|
def _cmd_del_controller(self, ctx, command):
|
|
br_name = command.args[0]
|
|
self._del_controller(ctx, br_name)
|
|
|
|
def _insert_controllers(self, controller_names):
|
|
ovsrec_controllers = []
|
|
for name in controller_names:
|
|
# TODO: check if the name startswith() supported protocols
|
|
ovsrec_controller = self.txn.insert(
|
|
self.txn.idl.tables[vswitch_idl.OVSREC_TABLE_CONTROLLER])
|
|
ovsrec_controller.target = name
|
|
ovsrec_controllers.append(ovsrec_controller)
|
|
return ovsrec_controllers
|
|
|
|
def _insert_qos(self):
|
|
ovsrec_qos = self.txn.insert(
|
|
self.txn.idl.tables[vswitch_idl.OVSREC_TABLE_QOS])
|
|
|
|
return ovsrec_qos
|
|
|
|
def _set_controller(self, ctx, br_name, controller_names):
|
|
ctx.populate_cache()
|
|
ovsrec_bridge = ctx.find_real_bridge(br_name, True).br_cfg
|
|
self._verify_controllers(ovsrec_bridge)
|
|
self._delete_controllers(ovsrec_bridge.controller)
|
|
controllers = self._insert_controllers(controller_names)
|
|
ovsrec_bridge.controller = controllers
|
|
|
|
def _cmd_set_controller(self, ctx, command):
|
|
br_name = command.args[0]
|
|
controller_names = command.args[1:]
|
|
self._set_controller(ctx, br_name, controller_names)
|
|
|
|
def _pre_fail_mode(self, ctx, command):
|
|
self._pre_get_info(ctx, command)
|
|
self.schema_helper.register_columns(
|
|
vswitch_idl.OVSREC_TABLE_BRIDGE,
|
|
[vswitch_idl.OVSREC_BRIDGE_COL_FAIL_MODE])
|
|
|
|
def _get_fail_mode(self, ctx, br_name):
|
|
ctx.populate_cache()
|
|
br = ctx.find_bridge(br_name, True)
|
|
|
|
# Note: Returns first element of fail_mode column
|
|
return getattr(br.br_cfg, vswitch_idl.OVSREC_BRIDGE_COL_FAIL_MODE)[0]
|
|
|
|
def _cmd_get_fail_mode(self, ctx, command):
|
|
br_name = command.args[0]
|
|
command.result = self._get_fail_mode(ctx, br_name)
|
|
|
|
def _del_fail_mode(self, ctx, br_name):
|
|
ctx.populate_cache()
|
|
br = ctx.find_bridge(br_name, True)
|
|
# Note: assuming that [] means empty
|
|
setattr(br.br_cfg, vswitch_idl.OVSREC_BRIDGE_COL_FAIL_MODE, [])
|
|
ctx.invalidate_cache()
|
|
|
|
def _cmd_del_fail_mode(self, ctx, command):
|
|
br_name = command.args[0]
|
|
self._del_fail_mode(ctx, br_name)
|
|
|
|
def _set_fail_mode(self, ctx, br_name, mode):
|
|
ctx.populate_cache()
|
|
br = ctx.find_bridge(br_name, True)
|
|
setattr(br.br_cfg, vswitch_idl.OVSREC_BRIDGE_COL_FAIL_MODE, mode)
|
|
ctx.invalidate_cache()
|
|
|
|
def _cmd_set_fail_mode(self, ctx, command):
|
|
br_name = command.args[0]
|
|
mode = command.args[1]
|
|
if mode not in ('standalone', 'secure'):
|
|
vsctl_fatal('fail-mode must be "standalone" or "secure"')
|
|
self._set_fail_mode(ctx, br_name, mode)
|
|
|
|
# Utility commands:
|
|
|
|
def _del_qos(self, ctx, port_name):
|
|
assert port_name is not None
|
|
|
|
ctx.populate_cache()
|
|
vsctl_port = ctx.find_port(port_name, True)
|
|
vsctl_qos = vsctl_port.qos
|
|
ctx.del_qos(vsctl_qos)
|
|
|
|
def _cmd_del_qos(self, ctx, command):
|
|
port_name = command.args[0]
|
|
self._del_qos(ctx, port_name)
|
|
|
|
def _set_qos(self, ctx, port_name, type, max_rate):
|
|
ctx.populate_cache()
|
|
vsctl_port = ctx.find_port(port_name, True)
|
|
ovsrec_qos = ctx.set_qos(vsctl_port, type, max_rate)
|
|
return ovsrec_qos
|
|
|
|
def _cmd_set_qos(self, ctx, command):
|
|
port_name = command.args[0]
|
|
type = command.args[1]
|
|
max_rate = command.args[2]
|
|
result = self._set_qos(ctx, port_name, type, max_rate)
|
|
command.result = [result]
|
|
|
|
def _pre_cmd_set_qos(self, ctx, command):
|
|
self._pre_get_info(ctx, command)
|
|
schema_helper = self.schema_helper
|
|
schema_helper.register_columns(
|
|
vswitch_idl.OVSREC_TABLE_QOS,
|
|
[vswitch_idl.OVSREC_QOS_COL_EXTERNAL_IDS,
|
|
vswitch_idl.OVSREC_QOS_COL_OTHER_CONFIG,
|
|
vswitch_idl.OVSREC_QOS_COL_QUEUES,
|
|
vswitch_idl.OVSREC_QOS_COL_TYPE])
|
|
|
|
def _cmd_set_queue(self, ctx, command):
|
|
ctx.populate_cache()
|
|
port_name = command.args[0]
|
|
queues = command.args[1]
|
|
vsctl_port = ctx.find_port(port_name, True)
|
|
vsctl_qos = vsctl_port.qos
|
|
queue_id = 0
|
|
results = []
|
|
for queue in queues:
|
|
max_rate = queue.get('max-rate', None)
|
|
min_rate = queue.get('min-rate', None)
|
|
ovsrec_queue = ctx.set_queue(
|
|
vsctl_qos, max_rate, min_rate, queue_id)
|
|
results.append(ovsrec_queue)
|
|
queue_id += 1
|
|
command.result = results
|
|
|
|
def _pre_cmd_set_queue(self, ctx, command):
|
|
self._pre_get_info(ctx, command)
|
|
schema_helper = self.schema_helper
|
|
schema_helper.register_columns(
|
|
vswitch_idl.OVSREC_TABLE_QUEUE,
|
|
[vswitch_idl.OVSREC_QUEUE_COL_DSCP,
|
|
vswitch_idl.OVSREC_QUEUE_COL_EXTERNAL_IDS,
|
|
vswitch_idl.OVSREC_QUEUE_COL_OTHER_CONFIG])
|
|
|
|
# Database commands:
|
|
|
|
_TABLES = [
|
|
_VSCtlTable(vswitch_idl.OVSREC_TABLE_BRIDGE,
|
|
[_VSCtlRowID(vswitch_idl.OVSREC_TABLE_BRIDGE,
|
|
vswitch_idl.OVSREC_BRIDGE_COL_NAME,
|
|
None)]),
|
|
_VSCtlTable(vswitch_idl.OVSREC_TABLE_CONTROLLER,
|
|
[_VSCtlRowID(vswitch_idl.OVSREC_TABLE_BRIDGE,
|
|
vswitch_idl.OVSREC_BRIDGE_COL_NAME,
|
|
vswitch_idl.OVSREC_BRIDGE_COL_CONTROLLER)]),
|
|
_VSCtlTable(vswitch_idl.OVSREC_TABLE_INTERFACE,
|
|
[_VSCtlRowID(vswitch_idl.OVSREC_TABLE_INTERFACE,
|
|
vswitch_idl.OVSREC_INTERFACE_COL_NAME,
|
|
None)]),
|
|
_VSCtlTable(vswitch_idl.OVSREC_TABLE_MIRROR,
|
|
[_VSCtlRowID(vswitch_idl.OVSREC_TABLE_MIRROR,
|
|
vswitch_idl.OVSREC_MIRROR_COL_NAME,
|
|
None)]),
|
|
_VSCtlTable(vswitch_idl.OVSREC_TABLE_MANAGER,
|
|
[_VSCtlRowID(vswitch_idl.OVSREC_TABLE_MANAGER,
|
|
vswitch_idl.OVSREC_MANAGER_COL_TARGET,
|
|
None)]),
|
|
_VSCtlTable(vswitch_idl.OVSREC_TABLE_NETFLOW,
|
|
[_VSCtlRowID(vswitch_idl.OVSREC_TABLE_BRIDGE,
|
|
vswitch_idl.OVSREC_BRIDGE_COL_NAME,
|
|
vswitch_idl.OVSREC_BRIDGE_COL_NETFLOW)]),
|
|
_VSCtlTable(vswitch_idl.OVSREC_TABLE_OPEN_VSWITCH,
|
|
[_VSCtlRowID(vswitch_idl.OVSREC_TABLE_OPEN_VSWITCH,
|
|
None,
|
|
None)]),
|
|
_VSCtlTable(vswitch_idl.OVSREC_TABLE_PORT,
|
|
[_VSCtlRowID(vswitch_idl.OVSREC_TABLE_PORT,
|
|
vswitch_idl.OVSREC_PORT_COL_NAME,
|
|
None)]),
|
|
_VSCtlTable(vswitch_idl.OVSREC_TABLE_QOS,
|
|
[_VSCtlRowID(vswitch_idl.OVSREC_TABLE_PORT,
|
|
vswitch_idl.OVSREC_PORT_COL_NAME,
|
|
vswitch_idl.OVSREC_PORT_COL_QOS)]),
|
|
_VSCtlTable(vswitch_idl.OVSREC_TABLE_QUEUE,
|
|
[_VSCtlRowID(vswitch_idl.OVSREC_TABLE_QOS,
|
|
None,
|
|
vswitch_idl.OVSREC_QOS_COL_QUEUES)]),
|
|
_VSCtlTable(vswitch_idl.OVSREC_TABLE_SSL,
|
|
[_VSCtlRowID(vswitch_idl.OVSREC_TABLE_OPEN_VSWITCH,
|
|
None,
|
|
vswitch_idl.OVSREC_OPEN_VSWITCH_COL_SSL)]),
|
|
_VSCtlTable(vswitch_idl.OVSREC_TABLE_SFLOW,
|
|
[_VSCtlRowID(vswitch_idl.OVSREC_TABLE_BRIDGE,
|
|
vswitch_idl.OVSREC_BRIDGE_COL_NAME,
|
|
vswitch_idl.OVSREC_BRIDGE_COL_SFLOW)]),
|
|
_VSCtlTable(vswitch_idl.OVSREC_TABLE_FLOW_TABLE,
|
|
[_VSCtlRowID(vswitch_idl.OVSREC_TABLE_FLOW_TABLE,
|
|
vswitch_idl.OVSREC_FLOW_TABLE_COL_NAME,
|
|
None)]),
|
|
]
|
|
|
|
@staticmethod
|
|
def _score_partial_match(name, s):
|
|
_MAX_SCORE = 0xffffffff
|
|
assert len(name) < _MAX_SCORE
|
|
s = s[:_MAX_SCORE - 1] # in practice, this doesn't matter
|
|
if name == s:
|
|
return _MAX_SCORE
|
|
|
|
name = name.lower().replace('-', '_')
|
|
s = s.lower().replace('-', '_')
|
|
if s.startswith(name):
|
|
return _MAX_SCORE - 1
|
|
if name.startswith(s):
|
|
return len(s)
|
|
|
|
return 0
|
|
|
|
@staticmethod
|
|
def _get_table(table_name):
|
|
best_match = None
|
|
best_score = 0
|
|
for table in VSCtl._TABLES:
|
|
score = VSCtl._score_partial_match(table.table_name, table_name)
|
|
if score > best_score:
|
|
best_match = table
|
|
best_score = score
|
|
elif score == best_score:
|
|
best_match = None
|
|
|
|
if best_match:
|
|
return best_match
|
|
elif best_score:
|
|
vsctl_fatal('multiple table names match "%s"' % table_name)
|
|
else:
|
|
vsctl_fatal('unknown table "%s"' % table_name)
|
|
|
|
def _pre_get_table(self, _ctx, table_name):
|
|
vsctl_table = self._get_table(table_name)
|
|
|
|
schema_helper = self.schema_helper
|
|
schema_helper.register_table(vsctl_table.table_name)
|
|
for row_id in vsctl_table.row_ids:
|
|
if row_id.table:
|
|
schema_helper.register_table(row_id.table)
|
|
if row_id.name_column:
|
|
schema_helper.register_columns(row_id.table,
|
|
[row_id.name_column])
|
|
if row_id.uuid_column:
|
|
schema_helper.register_columns(row_id.table,
|
|
[row_id.uuid_column])
|
|
return vsctl_table
|
|
|
|
def _get_column(self, table_name, column_name):
|
|
best_match = None
|
|
best_score = 0
|
|
|
|
columns = self.schema.tables[table_name].columns.keys()
|
|
for column in columns:
|
|
score = VSCtl._score_partial_match(column, column_name)
|
|
if score > best_score:
|
|
best_match = column
|
|
best_score = score
|
|
elif score == best_score:
|
|
best_match = None
|
|
|
|
if best_match:
|
|
# ovs.db.schema_helper._keep_table_columns() requires that
|
|
# column_name is type of str. Not unicode string
|
|
return str(best_match)
|
|
elif best_score:
|
|
vsctl_fatal('%s contains more than one column whose name '
|
|
'matches "%s"' % (table_name, column_name))
|
|
else:
|
|
vsctl_fatal('%s does not contain a column whose name matches '
|
|
'"%s"' % (table_name, column_name))
|
|
|
|
def _pre_get_column(self, _ctx, table_name, column):
|
|
column_name = self._get_column(table_name, column)
|
|
self.schema_helper.register_columns(table_name, [column_name])
|
|
|
|
def _pre_get_columns(self, ctx, table_name, columns):
|
|
self._pre_get_table(ctx, table_name)
|
|
for column in columns:
|
|
self._pre_get_column(ctx, table_name, column)
|
|
|
|
def _pre_cmd_list(self, ctx, command):
|
|
table_name = command.args[0]
|
|
self._pre_get_table(ctx, table_name)
|
|
|
|
def _list(self, ctx, table_name, record_id=None):
|
|
result = []
|
|
for ovsrec_row in ctx.idl.tables[table_name].rows.values():
|
|
if record_id is not None and ovsrec_row.name != record_id:
|
|
continue
|
|
result.append(ovsrec_row)
|
|
|
|
return result
|
|
|
|
def _cmd_list(self, ctx, command):
|
|
table_name = command.args[0]
|
|
record_id = None
|
|
if len(command.args) > 1:
|
|
record_id = command.args[1]
|
|
|
|
command.result = self._list(ctx, table_name, record_id)
|
|
|
|
def _pre_cmd_find(self, ctx, command):
|
|
table_name = command.args[0]
|
|
table_schema = self.schema.tables[table_name]
|
|
columns = [
|
|
ctx.parse_column_key_value(table_schema, column_key_value)[0]
|
|
for column_key_value in command.args[1:]]
|
|
|
|
self._pre_get_columns(ctx, table_name, columns)
|
|
|
|
def _check_value(self, ovsrec_row, column_value):
|
|
"""
|
|
:type column_value: tuple of column and value_json
|
|
"""
|
|
column, value_json = column_value
|
|
column_schema = ovsrec_row._table.columns[column]
|
|
value = ovs.db.data.Datum.from_json(
|
|
column_schema.type, value_json).to_python(ovs.db.idl._uuid_to_row)
|
|
datum = getattr(ovsrec_row, column)
|
|
if column_schema.type.is_map():
|
|
for k, v in value.items():
|
|
if k in datum and datum[k] == v:
|
|
return True
|
|
elif datum == value:
|
|
return True
|
|
|
|
return False
|
|
|
|
def _find(self, ctx, table_name, column_values):
|
|
"""
|
|
:type column_values: list of (column, value_json)
|
|
"""
|
|
result = []
|
|
for ovsrec_row in ctx.idl.tables[table_name].rows.values():
|
|
LOG.debug('ovsrec_row %s', ovsrec_row_to_string(ovsrec_row))
|
|
if all(self._check_value(ovsrec_row, column_value)
|
|
for column_value in column_values):
|
|
result.append(ovsrec_row)
|
|
|
|
return result
|
|
|
|
def _cmd_find(self, ctx, command):
|
|
table_name = command.args[0]
|
|
table_schema = self.schema.tables[table_name]
|
|
column_values = [
|
|
ctx.parse_column_key_value(table_schema, column_key_value)
|
|
for column_key_value in command.args[1:]]
|
|
command.result = self._find(ctx, table_name, column_values)
|
|
|
|
def _pre_cmd_get(self, ctx, command):
|
|
table_name = command.args[0]
|
|
columns = [
|
|
ctx.parse_column_key(column_key)[0]
|
|
for column_key in command.args[2:]]
|
|
|
|
self._pre_get_columns(ctx, table_name, columns)
|
|
|
|
def _get(self, ctx, table_name, record_id, column_keys,
|
|
id_=None, if_exists=False):
|
|
vsctl_table = self._get_table(table_name)
|
|
ovsrec_row = ctx.must_get_row(vsctl_table, record_id)
|
|
|
|
# TODO: Support symbol name
|
|
# if id_:
|
|
# symbol, new = ctx.create_symbol(id_)
|
|
# if not new:
|
|
# vsctl_fatal('row id "%s" specified on "get" command was '
|
|
# 'used before it was defined' % id_)
|
|
# symbol.uuid = row.uuid
|
|
# symbol.strong_ref = True
|
|
|
|
result = []
|
|
for column, key in column_keys:
|
|
result.append(ctx.get_column(ovsrec_row, column, key, if_exists))
|
|
|
|
return result
|
|
|
|
def _cmd_get(self, ctx, command):
|
|
id_ = None # TODO: Support --id option
|
|
if_exists = command.has_option('--if-exists')
|
|
table_name = command.args[0]
|
|
record_id = command.args[1]
|
|
|
|
column_keys = [
|
|
ctx.parse_column_key(column_key)
|
|
for column_key in command.args[2:]]
|
|
|
|
command.result = self._get(
|
|
ctx, table_name, record_id, column_keys, id_, if_exists)
|
|
|
|
def _check_mutable(self, table_name, column):
|
|
column_schema = self.schema.tables[table_name].columns[column]
|
|
if not column_schema.mutable:
|
|
vsctl_fatal('cannot modify read-only column %s in table %s' %
|
|
(column, table_name))
|
|
|
|
def _pre_mod_columns(self, ctx, table_name, columns):
|
|
self._pre_get_table(ctx, table_name)
|
|
for column in columns:
|
|
self._pre_get_column(ctx, table_name, column)
|
|
self._check_mutable(table_name, column)
|
|
|
|
def _pre_cmd_set(self, ctx, command):
|
|
table_name = command.args[0]
|
|
table_schema = self.schema.tables[table_name]
|
|
columns = [
|
|
ctx.parse_column_key_value(table_schema, column_key_value)[0]
|
|
for column_key_value in command.args[2:]]
|
|
|
|
self._pre_mod_columns(ctx, table_name, columns)
|
|
|
|
def _set(self, ctx, table_name, record_id, column_values):
|
|
"""
|
|
:type column_values: list of (column, value_json)
|
|
"""
|
|
vsctl_table = self._get_table(table_name)
|
|
ovsrec_row = ctx.must_get_row(vsctl_table, record_id)
|
|
for column, value in column_values:
|
|
ctx.set_column(ovsrec_row, column, value)
|
|
ctx.invalidate_cache()
|
|
|
|
def _cmd_set(self, ctx, command):
|
|
table_name = command.args[0]
|
|
record_id = command.args[1]
|
|
|
|
# column_key_value: <column>[:<key>]=<value>
|
|
table_schema = self.schema.tables[table_name]
|
|
column_values = [
|
|
ctx.parse_column_key_value(table_schema, column_key_value)
|
|
for column_key_value in command.args[2:]]
|
|
|
|
self._set(ctx, table_name, record_id, column_values)
|
|
|
|
def _pre_cmd_add(self, ctx, command):
|
|
table_name = command.args[0]
|
|
columns = [command.args[2]]
|
|
|
|
self._pre_mod_columns(ctx, table_name, columns)
|
|
|
|
def _add(self, ctx, table_name, record_id, column_values):
|
|
"""
|
|
:type column_values: list of (column, value_json)
|
|
"""
|
|
vsctl_table = self._get_table(table_name)
|
|
ovsrec_row = ctx.must_get_row(vsctl_table, record_id)
|
|
for column, value in column_values:
|
|
ctx.add_column(ovsrec_row, column, value)
|
|
ctx.invalidate_cache()
|
|
|
|
def _cmd_add(self, ctx, command):
|
|
table_name = command.args[0]
|
|
record_id = command.args[1]
|
|
column = command.args[2]
|
|
|
|
column_key_value_strings = []
|
|
for value in command.args[3:]:
|
|
if '=' in value:
|
|
# construct <column>:<key>=value
|
|
column_key_value_strings.append('%s:%s' % (column, value))
|
|
else:
|
|
# construct <column>=value
|
|
column_key_value_strings.append('%s=%s' % (column, value))
|
|
|
|
table_schema = self.schema.tables[table_name]
|
|
column_values = [
|
|
ctx.parse_column_key_value(table_schema, column_key_value_string)
|
|
for column_key_value_string in column_key_value_strings]
|
|
|
|
self._add(ctx, table_name, record_id, column_values)
|
|
|
|
def _pre_cmd_remove(self, ctx, command):
|
|
table_name = command.args[0]
|
|
columns = [command.args[2]]
|
|
|
|
self._pre_mod_columns(ctx, table_name, columns)
|
|
|
|
def _remove(self, ctx, table_name, record_id, column_values):
|
|
"""
|
|
:type column_values: list of (column, value_json)
|
|
"""
|
|
vsctl_table = self._get_table(table_name)
|
|
ovsrec_row = ctx.must_get_row(vsctl_table, record_id)
|
|
for column, value in column_values:
|
|
ctx.remove_column(ovsrec_row, column, value)
|
|
ctx.invalidate_cache()
|
|
|
|
def _cmd_remove(self, ctx, command):
|
|
table_name = command.args[0]
|
|
record_id = command.args[1]
|
|
column = command.args[2]
|
|
|
|
column_key_value_strings = []
|
|
for value in command.args[3:]:
|
|
if '=' in value:
|
|
# construct <column>:<key>=value
|
|
column_key_value_strings.append('%s:%s' % (column, value))
|
|
else:
|
|
# construct <column>=value
|
|
column_key_value_strings.append('%s=%s' % (column, value))
|
|
|
|
table_schema = self.schema.tables[table_name]
|
|
column_values = [
|
|
ctx.parse_column_key_value(table_schema, column_key_value_string)
|
|
for column_key_value_string in column_key_value_strings]
|
|
|
|
self._remove(ctx, table_name, record_id, column_values)
|
|
|
|
def _pre_cmd_clear(self, ctx, command):
|
|
table_name = command.args[0]
|
|
column = command.args[2]
|
|
self._pre_mod_columns(ctx, table_name, [column])
|
|
|
|
def _clear(self, ctx, table_name, record_id, column):
|
|
vsctl_table = self._get_table(table_name)
|
|
ovsrec_row = ctx.must_get_row(vsctl_table, record_id)
|
|
column_schema = ctx.idl.tables[table_name].columns[column]
|
|
if column_schema.type.n_min > 0:
|
|
vsctl_fatal('"clear" operation cannot be applied to column %s '
|
|
'of table %s, which is not allowed to be empty' %
|
|
(column, table_name))
|
|
|
|
# assuming that default datum is empty.
|
|
default_datum = ovs.db.data.Datum.default(column_schema.type)
|
|
setattr(ovsrec_row, column,
|
|
default_datum.to_python(ovs.db.idl._uuid_to_row))
|
|
ctx.invalidate_cache()
|
|
|
|
def _cmd_clear(self, ctx, command):
|
|
table_name = command.args[0]
|
|
record_id = command.args[1]
|
|
column = command.args[2]
|
|
self._clear(ctx, table_name, record_id, column)
|
|
|
|
|
|
#
|
|
# Create constants from ovs db schema
|
|
#
|
|
|
|
def schema_print(schema_location, prefix):
|
|
prefix = prefix.upper()
|
|
|
|
json = ovs.json.from_file(schema_location)
|
|
schema = ovs.db.schema.DbSchema.from_json(json)
|
|
|
|
print('# Do NOT edit.')
|
|
print('# This is automatically generated by %s' % __file__)
|
|
print('# created based on version %s' % (schema.version or 'unknown'))
|
|
print('')
|
|
print('')
|
|
print('%s_DB_NAME = \'%s\'' % (prefix, schema.name))
|
|
for table in sorted(schema.tables.values(),
|
|
key=operator.attrgetter('name')):
|
|
print('')
|
|
print('%s_TABLE_%s = \'%s\'' % (prefix,
|
|
table.name.upper(), table.name))
|
|
for column in sorted(table.columns.values(),
|
|
key=operator.attrgetter('name')):
|
|
print('%s_%s_COL_%s = \'%s\'' % (prefix, table.name.upper(),
|
|
column.name.upper(),
|
|
column.name))
|
|
|
|
|
|
def main():
|
|
if len(sys.argv) <= 2:
|
|
print('Usage: %s <schema file>' % sys.argv[0])
|
|
print('e.g.: %s vswitchd/vswitch.ovsschema' % sys.argv[0])
|
|
|
|
location = sys.argv[1]
|
|
prefix = 'OVSREC'
|
|
schema_print(location, prefix)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|