def create_qos(self):
qos_table = ovsdb.get_table(self, self.system_id, 'QoS')
if len(qos_table.rows.values())>0:
self.qos_uuid = qos_table.rows.values()[0].uuid
print "\033[1;32;49mUse old qos: {}\033[0;37;49m".format(self.qos_uuid)
return True
def _create_qos(tables, insert):
# insert new qos
qos = insert(tables['QoS'])
qos.other_config = {'max-rate': QOS_MAX_RATE}
qos.type = "linux-htb"
# return local uuid(s), this will create a map in rep.insert_uuids
# {local uuid: real uuid in ovsdb}
return qos.uuid
req = ovsdb_event.EventModifyRequest(self.system_id, _create_qos)
rep = self.send_request(req)
self.qos_uuid = rep.insert_uuids.values()[0] # insert_uuids is a uuid map
print "\033[1;32;49mCreate qos: {}\033[0;37;49m".format(self.qos_uuid)
if rep.status != 'success':
return False
return True
def set_controller(manager,
system_id,
bridge_name,
target,
controller_info=None):
controller_info = controller_info or {}
def _set_controller(tables, insert):
bridge = _get_bridge(tables, bridge_name)
controller = _get_controller(tables, target)
_uuid = None
if not controller:
_uuid = controller_info.get('uuid', uuid.uuid4())
controller = insert(tables['Controller'], _uuid)
controller.target = target
controller.connection_mode = ['out-of-band']
elif 'out-of-band' not in controller.connection_mode:
controller.connection_mode = ['out-of-band']
if controller_info:
for key, val in controller_info.items():
setattr(controller, key, val)
bridge.controller = [controller]
return _uuid
req = ovsdb_event.EventModifyRequest(system_id, _set_controller)
return manager.send_request(req)
def set_controller(self, system_id, bridge_name, controller_url, bridge_uuid=None):
new_controller_uuid = uuid.uuid4()
def _set_controller(tables, insert):
controller = insert(tables['Controller'], new_controller_uuid)
controller.target = controller_url
bridge = None
if bridge_uuid:
bridge = tables['Bridge'].rows.get(bridge_uuid)
else:
bridges = list(tables['Bridge'].rows.values())
for br in bridges:
if br.name == bridge_name:
bridge = br
break
if bridge:
bridge.controller = [controller]
return (new_controller_uuid, )
req = ovsdb_event.EventModifyRequest(system_id, _set_controller)
rep = self.send_request(req)
if rep.status != 'success':
self.logger.error('Error adding controller %s: %s',
controller_url, rep.status)
return None
else:
self.logger.info('added controller %s with uuid %s to bridge %s successfully', controller_url,
new_controller_uuid.hex, bridge_name)
return rep.insert_uuids[new_controller_uuid]
def create_port(self, system_id, bridge_name, name):
new_iface_uuid = uuid.uuid4()
new_port_uuid = uuid.uuid4()
bridge = ovsdb.row_by_name(self, system_id, bridge_name)
def _create_port(tables, insert):
iface = insert(tables['Interface'], new_iface_uuid)
iface.name = name
port = insert(tables['Port'], new_port_uuid)
port.name = name
port.interfaces = [iface]
bridge.ports = bridge.ports + [port]
return new_port_uuid, new_iface_uuid
req = ovsdb_event.EventModifyRequest(system_id, _create_port)
rep = self.send_request(req)
if rep.status != 'success':
self.logger.error('Error creating port %s on bridge %s: %s',
name, bridge, rep.status)
return None
return rep.insert_uuids[new_port_uuid]
def set_openflow_versions(self, system_id, bridge_name, protocols=[], bridge_uuid=None):
def _set_openflow_versions(tables, insert):
bridge = None
if bridge_uuid:
bridge = tables['Bridge'].rows.get(bridge_uuid)
else:
bridges = list(tables['Bridge'].rows.values())
for br in bridges:
if br.name == bridge_name:
bridge = br
break
if bridge:
bridge.protocols = protocols
return (bridge.uuid, ) if bridge else ()
req = ovsdb_event.EventModifyRequest(system_id, _set_openflow_versions)
rep = self.send_request(req)
if rep.status != 'success':
self.logger.error('Error setting openflow protocols %s: %s',
protocols, rep.status)
return None
else:
self.logger.info('OpenFlow protocols %s added to bridge %s successfully', str(protocols), bridge_name)
return rep
def create_port(manager,
system_id,
bridge_name,
port_info,
iface_info=None,
port_insert_uuid=None,
iface_insert_uuid=None):
if iface_info is None:
iface_info = {}
if not port_insert_uuid:
port_insert_uuid = uuid.uuid4()
if not iface_insert_uuid:
iface_insert_uuid = uuid.uuid4()
def _create_port(tables, insert):
bridge = _get_bridge(tables, bridge_name)
if not bridge:
return
default_port_name = 'port' + str(port_insert_uuid)
if 'name' not in iface_info:
iface_info['name'] = port_info.get('name', default_port_name)
if 'type' not in iface_info:
iface_info['type'] = 'internal'
if 'name' not in port_info:
port_info['name'] = default_port_name
iface = insert(tables['Interface'], iface_insert_uuid)
for key, val in iface_info.items():
setattr(iface, key, val)
port = insert(tables['Port'], port_insert_uuid)
for key, val in port_info.items():
setattr(port, key, val)
port.interfaces = [iface]
bridge.ports = bridge.ports + [port]
return port_insert_uuid, iface_insert_uuid
req = ovsdb_event.EventModifyRequest(system_id, _create_port)
return manager.send_request(req)
def del_other_config(manager, system_id, key, fn):
def _del_iface_other_config(tables, *_):
row = fn(tables)
if not row:
return None
other_config = row.other_config
if key in other_config:
other_config.pop(key)
row.other_config = other_config
req = ovsdb_event.EventModifyRequest(system_id, _del_iface_other_config)
return manager.send_request(req)
def del_external_id(manager, system_id, key, fn):
def _del_iface_external_id(tables, *_):
row = fn(tables)
if not row:
return None
external_ids = row.external_ids
if key in external_ids:
external_ids.pop(key)
row.external_ids = external_ids
req = ovsdb_event.EventModifyRequest(system_id, _del_iface_external_id)
return manager.send_request(req)
def prepare_and_bind_queue(self, queue_id, min_rate):
# get qos row by uuid
# XXX: In this app, only one qos is used
qos_table = ovsdb.get_table(self, self.system_id, 'QoS')
qos = qos_table.rows.get(self.qos_uuid, None)
if qos is None:
print "Error: qos row doesn't esxit!!"
return
# try to get old queue by qid
old_queue = None
try:
old_queue_uuid = qos.queues[int(queue_id)].uuid
# get Row of the old_queue
queue_table = ovsdb.get_table(self, self.system_id, 'Queue')
old_queue = queue_table.rows.get(old_queue_uuid) # Row obj
except:
pass
def _prepare_and_bind_queue(tables, insert):
if old_queue:
queue = old_queue
print "\033[1;32;49mOld queue min-rate is changed to {0}: {1}\033[0;37;49m".format(min_rate, queue.uuid)
else:
queue = insert(tables['Queue'])
queue.other_config = {'min-rate': str(min_rate)}
# Bind qos -> queue
# Need to assign the column back to Row obj; otherwise, it won't modify the ovsdb
tmp = qos.queues
tmp[int(queue_id)] = queue.uuid
qos.queues = tmp
print 'Bind ovsdb: qos -> queues'
return queue.uuid
req = ovsdb_event.EventModifyRequest(self.system_id, _prepare_and_bind_queue)
rep = self.send_request(req)
if rep.insert_uuids.values()[0]:
print "\033[1;32;49mCreate queue: {}\033[0;37;49m".format(rep.insert_uuids.values()[0])
if rep.status != 'success':
return False
return True
def set_other_config(manager, system_id, key, val, fn):
val = str(val)
def _set_iface_other_config(tables, *_):
row = fn(tables)
if not row:
return None
other_config = row.other_config
other_config[key] = val
row.other_config = other_config
req = ovsdb_event.EventModifyRequest(system_id, _set_iface_other_config)
return manager.send_request(req)
def set_external_id(manager, system_id, key, val, fn):
val = str(val)
def _set_iface_external_id(tables, *_):
row = fn(tables)
if not row:
return None
external_ids = row.external_ids
external_ids[key] = val
row.external_ids = external_ids
req = ovsdb_event.EventModifyRequest(system_id, _set_iface_external_id)
return manager.send_request(req)
def del_port(manager, system_id, bridge_name, fn):
def _delete_port(tables, *_):
bridge = _get_bridge(tables, bridge_name)
if not bridge:
return
port = fn(tables)
if not port:
return
ports = bridge.ports
ports.remove(port)
bridge.ports = ports
req = ovsdb_event.EventModifyRequest(system_id, _delete_port)
return manager.send_request(req)
def create_bridge(self, system_id, bridge_name):
new_bridge_uuid = uuid.uuid4()
def _create_bridge(tables, insert):
bridge = insert(tables['Bridge'], new_bridge_uuid)
bridge.name = bridge_name
list(tables['Open_vSwitch'].rows.values())[0].bridges += [bridge]
return (new_bridge_uuid, )
req = ovsdb_event.EventModifyRequest(system_id, _create_bridge)
rep = self.send_request(req)
if rep.status != 'success':
self.logger.error('Error creating bridge %s: %s',
bridge_name, rep.status)
return None
else:
self.logger.info('created bridge %s with uuid %s successfully', bridge_name, new_bridge_uuid.hex)
return rep.insert_uuids[new_bridge_uuid]
def bind_qos(self):
qos_uuid = self.qos_uuid
# get port table
ports = ovsdb.get_table(self, self.system_id, 'Port')
def _bind_qos(tables, insert):
# Bind port -> qos
for row in ports.rows.values():
row.qos = qos_uuid
print 'Bind ovsdb: port -> qos'
return None
req = ovsdb_event.EventModifyRequest(self.system_id, _bind_qos)
rep = self.send_request(req)
if rep.status != 'success':
return False
return True
