mir/ovs
2
0
Fork 0
mirror of https://github.com/openvswitch/ovs synced 2025-08-22 01:51:26 +00:00
Code Issues Releases Wiki Activity
ovs/vtep/ovs-vtep.in
Vasyl Saienko 96ee23a218 ovs-vtep: Fix vlan binding. 
When bind port to multiple logical switches with
vlan and without vlan tag rules are generated without
priority. Rule without tag is more generic and matches
all traffic by in_port selector.
Since both rules has same priority first rule wins.
This patch adds priority to vlan based rule as 200
and 100 for rule without vlan to make sure rules with
vlan checked first.

Signed-off-by: Vasyl Saienko <vsaienko@mirantis.com>
Signed-off-by: Aaron Conole <aconole@redhat.com>
2025-04-23 14:24:55 -04:00

777 lines
27 KiB
Plaintext
Executable File
Raw Permalink Blame History

#! @PYTHON3@
# Copyright (C) 2013 Nicira, Inc. All Rights Reserved.
#
# 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.
# Limitations:
# - Doesn't support multicast other than "unknown-dst"
import argparse
import re
import shlex
import subprocess
import sys
import time
import ovs.daemon
import ovs.dirs
import ovs.unixctl.server
import ovs.util
import ovs.vlog
VERSION = "0.99"
root_prefix = ""
__pychecker__ = 'no-reuseattr' # Remove in pychecker >= 0.8.19.
vlog = ovs.vlog.Vlog("ovs-vtep")
verbose_args = []
exiting = False
ps_name = ""
ps_type = ""
Tunnel_Ip = ""
Lswitches = {}
Bindings = {}
ls_count = 0
tun_id = 0
bfd_bridge = "vtep_bfd"
bfd_ref = {}
def call_prog(prog, args_list):
cmd = [prog] + verbose_args + ["-vconsole:off"] + args_list
creationFlags = 0
if sys.platform == 'win32':
creationFlags = 0x08000000 # CREATE_NO_WINDOW
output = subprocess.Popen(cmd, stdout=subprocess.PIPE,
creationflags=creationFlags).communicate()
if len(output) == 0 or output[0] is None:
output = ""
else:
output = output[0].decode().strip()
return output
def ovs_vsctl(args):
return call_prog("ovs-vsctl", shlex.split(args))
def ovs_ofctl(args):
return call_prog("ovs-ofctl", shlex.split(args))
def vtep_ctl(args):
return call_prog("vtep-ctl", shlex.split(args))
def unixctl_exit(conn, unused_argv, unused_aux):
global exiting
exiting = True
conn.reply(None)
class Logical_Switch(object):
def __init__(self, ls_name, ps_name):
global ls_count
self.name = ls_name
ls_count += 1
self.short_name = ps_name + "_vtep_ls" + str(ls_count)
vlog.info("creating lswitch %s (%s)" % (self.name, self.short_name))
self.ports = {}
self.tunnels = {}
self.local_macs = set()
self.remote_macs = {}
self.unknown_dsts = set()
self.setup_ls()
self.replication_mode = "service_node"
def __del__(self):
vlog.info("destroying lswitch %s" % self.name)
def setup_ls(self):
if ps_type:
ovs_vsctl("--may-exist add-br %s -- set Bridge %s datapath_type=%s"
% (self.short_name, self.short_name, ps_type))
else:
ovs_vsctl("--may-exist add-br %s" % self.short_name)
ovs_vsctl("br-set-external-id %s vtep_logical_switch true"
% self.short_name)
ovs_vsctl("br-set-external-id %s logical_switch_name %s"
% (self.short_name, self.name))
vtep_ctl("clear-local-macs %s" % self.name)
vtep_ctl("add-mcast-local %s unknown-dst %s" % (self.name, Tunnel_Ip))
ovs_ofctl("del-flows %s" % self.short_name)
ovs_ofctl("add-flow %s priority=0,action=drop" % self.short_name)
def cleanup_ls(self):
for port_no, tun_name, remote_ip in self.tunnels.values():
del_bfd(remote_ip)
def update_flood(self):
flood_ports = list(self.ports.values())
# Traffic flowing from one 'unknown-dst' should not be flooded to
# port belonging to another 'unknown-dst'.
for tunnel in self.unknown_dsts:
port_no = self.tunnels[tunnel][0]
ovs_ofctl("add-flow %s table=1,priority=1,in_port=%s,action=%s"
% (self.short_name, port_no, ",".join(flood_ports)))
# Traffic coming from a VTEP physical port should always be flooded to
# all the other physical ports that belong to that VTEP device and
# this logical switch. If the replication mode is service node then
# send to one unknown_dst node (the first one here); else we assume the
# replication mode is source node and we send the packet to all
# unknown_dst nodes.
for tunnel in self.unknown_dsts:
port_no = self.tunnels[tunnel][0]
flood_ports.append(port_no)
if self.replication_mode == "service_node":
break
ovs_ofctl("add-flow %s table=1,priority=0,action=%s"
% (self.short_name, ",".join(flood_ports)))
def add_lbinding(self, lbinding):
vlog.info("adding %s binding to %s" % (lbinding, self.name))
port_no = ovs_vsctl("get Interface %s ofport" % lbinding)
self.ports[lbinding] = port_no
ovs_ofctl("add-flow %s in_port=%s,action=learn(table=1,"
"priority=1000,idle_timeout=15,cookie=0x5000,"
"NXM_OF_ETH_DST[]=NXM_OF_ETH_SRC[],"
"output:NXM_OF_IN_PORT[]),resubmit(,1)"
% (self.short_name, port_no))
self.update_flood()
def del_lbinding(self, lbinding):
vlog.info("removing %s binding from %s" % (lbinding, self.name))
port_no = self.ports[lbinding]
ovs_ofctl("del-flows %s in_port=%s" % (self.short_name, port_no))
del self.ports[lbinding]
self.update_flood()
def add_tunnel(self, tunnel, tunnel_key):
global tun_id
vlog.info("adding tunnel %s" % tunnel)
encap, ip = tunnel.split("/")
if encap != "vxlan_over_ipv4":
vlog.warn("unsupported tunnel format %s" % encap)
return
tun_id += 1
tun_name = "vx" + str(tun_id)
ovs_vsctl("add-port %s %s -- set Interface %s type=vxlan "
"options:key=%s options:remote_ip=%s"
% (self.short_name, tun_name, tun_name, tunnel_key, ip))
for i in range(10):
port_no = ovs_vsctl("get Interface %s ofport" % tun_name)
if port_no != "-1":
break
elif i == 9:
vlog.warn("couldn't create tunnel %s" % tunnel)
ovs_vsctl("del-port %s %s" % (self.short_name, tun_name))
return
# Give the system a moment to allocate the port number
time.sleep(0.5)
self.tunnels[tunnel] = (port_no, tun_name, ip)
add_bfd(ip)
ovs_ofctl("add-flow %s table=0,priority=1000,in_port=%s,"
"actions=resubmit(,1)"
% (self.short_name, port_no))
def del_tunnel(self, tunnel):
vlog.info("removing tunnel %s" % tunnel)
port_no, tun_name, remote_ip = self.tunnels[tunnel]
ovs_ofctl("del-flows %s table=0,in_port=%s"
% (self.short_name, port_no))
ovs_vsctl("del-port %s %s" % (self.short_name, tun_name))
del_bfd(remote_ip)
del self.tunnels[tunnel]
def update_local_macs(self):
flows = ovs_ofctl("dump-flows %s cookie=0x5000/-1,table=1"
% self.short_name).splitlines()
macs = set()
for f in flows:
mac = re.split(r'.*dl_dst=(.*) .*', f)
if len(mac) == 3:
macs.add(mac[1])
for mac in macs.difference(self.local_macs):
vlog.info("adding local ucast %s to %s" % (mac, self.name))
vtep_ctl("add-ucast-local %s %s %s" % (self.name, mac, Tunnel_Ip))
for mac in self.local_macs.difference(macs):
vlog.info("removing local ucast %s from %s" % (mac, self.name))
vtep_ctl("del-ucast-local %s %s" % (self.name, mac))
self.local_macs = macs
def add_remote_mac(self, mac, tunnel):
port_no = self.tunnels.get(tunnel, (0, ""))[0]
if not port_no:
return
ovs_ofctl("add-flow %s table=1,priority=1000,dl_dst=%s,action=%s"
% (self.short_name, mac, port_no))
def del_remote_mac(self, mac):
ovs_ofctl("del-flows %s table=1,dl_dst=%s" % (self.short_name, mac))
def update_remote_macs(self):
remote_macs = {}
unknown_dsts = set()
tunnels = set()
parse_ucast = True
column = vtep_ctl("--columns=tunnel_key find logical_switch "
"name=%s" % self.name)
tunnel_key = column.partition(":")[2].strip()
if tunnel_key and isinstance(eval(tunnel_key), int):
vlog.info("update_remote_macs: using tunnel key %s in %s"
% (tunnel_key, self.name))
else:
vlog.info("Invalid tunnel key %s in %s post VTEP DB requery"
% (tunnel_key, self.name))
return
mac_list = vtep_ctl("list-remote-macs %s" % self.name).splitlines()
for line in mac_list:
if (line.find("mcast-mac-remote") != -1):
parse_ucast = False
continue
entry = re.split(r' (.*) -> (.*)', line)
if len(entry) != 4:
continue
if parse_ucast:
remote_macs[entry[1]] = entry[2]
else:
if entry[1] != "unknown-dst":
continue
unknown_dsts.add(entry[2])
tunnels.add(entry[2])
old_tunnels = set(self.tunnels.keys())
for tunnel in tunnels.difference(old_tunnels):
self.add_tunnel(tunnel, tunnel_key)
for tunnel in old_tunnels.difference(tunnels):
self.del_tunnel(tunnel)
for mac in remote_macs.keys():
if (self.remote_macs.get(mac) != remote_macs[mac]):
self.add_remote_mac(mac, remote_macs[mac])
for mac in self.remote_macs.keys():
if mac not in remote_macs:
self.del_remote_mac(mac)
self.remote_macs = remote_macs
replication_mode = vtep_ctl("get logical_switch %s replication_mode"
% self.name)
# Replication mode is an optional column and if it is not set,
# replication mode defaults to service_node.
if replication_mode == "[]":
replication_mode = "service_node"
# If the logical switch level replication mode has changed then
# update to that value.
update_flood_set = False
if replication_mode != self.replication_mode:
self.replication_mode = replication_mode
vlog.info("%s replication mode changed to %s" %
(self.name, self.replication_mode))
update_flood_set = True
if (self.unknown_dsts != unknown_dsts):
self.unknown_dsts = unknown_dsts
update_flood_set = True
# If either the replication mode has changed or the unknown
# destinations set has changed, update the flooding decision.
if update_flood_set is True:
self.update_flood()
def update_stats(self):
# Map Open_vSwitch's "interface:statistics" to columns of
# vtep's logical_binding_stats. Since we are using the 'interface' from
# the logical switch to collect stats, packets transmitted from it
# is received in the physical switch and vice versa.
stats_map = {'tx_packets': 'packets_to_local',
'tx_bytes': 'bytes_to_local',
'rx_packets': 'packets_from_local',
'rx_bytes': 'bytes_from_local'}
# Go through all the logical switch's interfaces that end with "-l"
# and copy the statistics to logical_binding_stats.
for interface in self.ports.keys():
if not interface.endswith("-l"):
continue
# Physical ports can have a '-' as part of its name.
vlan, remainder = interface.split("-", 1)
pp_name, logical = remainder.rsplit("-", 1)
uuid = vtep_ctl("get physical_port %s vlan_stats:%s"
% (pp_name, vlan))
if not uuid:
continue
for mapfrom, mapto in stats_map.items():
value = ovs_vsctl("get interface %s statistics:%s"
% (interface, mapfrom)).strip('"')
vtep_ctl("set logical_binding_stats %s %s=%s"
% (uuid, mapto, value))
def run(self):
self.update_local_macs()
self.update_remote_macs()
self.update_stats()
def get_vtep_tunnel(remote_ip):
# Get the physical_locator record for the local tunnel end point.
column = vtep_ctl("--columns=_uuid find physical_locator "
"dst_ip=%s" % Tunnel_Ip)
local = column.partition(":")[2].strip()
if not local:
return (None, None, None)
# Get the physical_locator record for the remote tunnel end point.
column = vtep_ctl("--columns=_uuid find physical_locator "
"dst_ip=%s" % remote_ip)
remote = column.partition(":")[2].strip()
if not remote:
return (None, None, None)
column = vtep_ctl("--columns=_uuid find tunnel "
"local=%s remote=%s" % (local, remote))
tunnel = column.partition(":")[2].strip()
return (local, remote, tunnel)
def create_vtep_tunnel(remote_ip):
local, remote, tunnel = get_vtep_tunnel(remote_ip)
if not local or not remote:
return None
if not tunnel:
vlog.info("creating tunnel record in vtep for remote_ip:%s"
% remote_ip)
tunnel = vtep_ctl("add physical_switch %s tunnels @tun -- "
"--id=@tun create Tunnel local=%s remote=%s"
% (ps_name, local, remote))
return tunnel
def destroy_vtep_tunnel(remote_ip):
local, remote, tunnel = get_vtep_tunnel(remote_ip)
if tunnel:
vlog.info("destroying tunnel record in vtep for remote_ip:%s"
% remote_ip)
vtep_ctl("remove physical_switch %s tunnels %s "
"-- --if-exists destroy tunnel %s"
% (ps_name, tunnel, tunnel))
def add_bfd(remote_ip):
# The VTEP emulator creates one OVS bridge for every logical switch.
# Multiple logical switches can have multiple OVS tunnels to the
# same machine (with different tunnel ids). But VTEP schema expects
# a single BFD session between two physical locators. Therefore
# create a separate bridge ('bfd_bridge') and create a single OVS tunnel
# between two phsyical locators (using reference counter).
if remote_ip in bfd_ref:
bfd_ref[remote_ip] += 1
return
vlog.info("adding bfd tunnel for remote_ip:%s" % remote_ip)
port_name = "bfd" + remote_ip
# Don't enable BFD yet. Enabling or disabling BFD is based on
# the controller setting a value in VTEP DB's tunnel record.
ovs_vsctl("--may-exist add-port %s %s "
" -- set Interface %s type=vxlan options:remote_ip=%s"
% (bfd_bridge, port_name, port_name, remote_ip))
bfd_ref[remote_ip] = 1
# Ideally, we should create a 'tunnel' record in the VTEP DB here.
# To create a 'tunnel' record, we need 2 entries in 'physical_locator'
# table (one for local and one for remote). But, 'physical_locator'
# can be created/destroyed asynchronously when the remote controller
# adds/removes entries in Ucast_Macs_Remote table. To prevent race
# conditions, pass the responsibility of creating a 'tunnel' record
# to run_bfd() which runs more often.
def del_bfd(remote_ip):
if remote_ip in bfd_ref:
if bfd_ref[remote_ip] == 1:
port_name = "bfd" + remote_ip
vlog.info("deleting bfd tunnel for remote_ip:%s" % remote_ip)
ovs_vsctl("--if-exists del-port %s" % port_name)
destroy_vtep_tunnel(remote_ip)
del bfd_ref[remote_ip]
else:
bfd_ref[remote_ip] -= 1
def run_bfd():
bfd_ports = ovs_vsctl("list-ports %s" % bfd_bridge).split()
for port in bfd_ports:
remote_ip = ovs_vsctl("get interface %s options:remote_ip" % port)
tunnel = create_vtep_tunnel(remote_ip)
if not tunnel:
continue
bfd_params_default = {'bfd_params:enable': 'false',
'bfd_params:min_rx': 1000,
'bfd_params:min_tx': 100,
'bfd_params:decay_min_rx': 0,
'bfd_params:cpath_down': 'false',
'bfd_params:check_tnl_key': 'false'}
bfd_params_values = {}
for key, default in bfd_params_default.items():
column = vtep_ctl("--if-exists get tunnel %s %s"
% (tunnel, key))
if not column:
bfd_params_values[key] = default
else:
bfd_params_values[key] = column
for key, value in bfd_params_values.items():
new_key = key.replace('_params', '')
ovs_vsctl("set interface %s %s=%s" % (port, new_key, value))
bfd_status = ['bfd_status:state', 'bfd_status:forwarding',
'bfd_status:diagnostic', 'bfd_status:remote_state',
'bfd_status:remote_diagnostic']
for key in bfd_status:
value = ovs_vsctl("--if-exists get interface %s %s" % (port, key))
if value:
vtep_ctl("set tunnel %s %s=%s" % (tunnel, key, value))
else:
new_key = key.replace('bfd_status:', '')
vtep_ctl("remove tunnel %s bfd_status %s" % (tunnel, new_key))
vtep_ctl("set tunnel %s bfd_status:enabled=%s"
% (tunnel, bfd_params_values['bfd_params:enable']))
# Add the defaults as described in VTEP schema to make it explicit.
bfd_lconf_default = {'bfd_config_local:bfd_dst_ip': '169.254.1.0',
'bfd_config_local:bfd_dst_mac':
'00:23:20:00:00:01'}
for key, value in bfd_lconf_default.items():
vtep_ctl("set tunnel %s %s=%s" % (tunnel, key, value))
# bfd_config_remote options from VTEP DB should be populated to
# corresponding OVS DB values.
bfd_dst_ip = vtep_ctl("--if-exists get tunnel %s "
"bfd_config_remote:bfd_dst_ip" % (tunnel))
if not bfd_dst_ip:
bfd_dst_ip = "169.254.1.1"
bfd_dst_mac = vtep_ctl("--if-exists get tunnel %s "
"bfd_config_remote:bfd_dst_mac" % (tunnel))
if not bfd_dst_mac:
bfd_dst_mac = "00:23:20:00:00:01"
ovs_vsctl("set interface %s bfd:bfd_dst_ip=%s "
"bfd:bfd_remote_dst_mac=%s bfd:bfd_local_dst_mac=%s"
% (port, bfd_dst_ip,
bfd_lconf_default['bfd_config_local:bfd_dst_mac'],
bfd_dst_mac))
def add_binding(binding, ls):
vlog.info("adding binding %s" % binding)
vlan, pp_name = binding.split("-", 1)
pbinding = binding + "-p"
lbinding = binding + "-l"
# Create a patch port that connects the VLAN+port to the lswitch.
# Do them as two separate calls so if one side already exists, the
# other side is created.
ovs_vsctl("add-port %s %s "
" -- set Interface %s type=patch options:peer=%s"
% (ps_name, pbinding, pbinding, lbinding))
ovs_vsctl("add-port %s %s "
" -- set Interface %s type=patch options:peer=%s"
% (ls.short_name, lbinding, lbinding, pbinding))
port_no = ovs_vsctl("get Interface %s ofport" % pp_name)
patch_no = ovs_vsctl("get Interface %s ofport" % pbinding)
vlan_ = vlan.lstrip('0')
if vlan_:
ovs_ofctl("add-flow %s priority=200,in_port=%s,dl_vlan=%s,"
"action=strip_vlan,%s"
% (ps_name, port_no, vlan_, patch_no))
ovs_ofctl("add-flow %s priority=200,in_port=%s,"
"action=mod_vlan_vid:%s,%s"
% (ps_name, patch_no, vlan_, port_no))
else:
ovs_ofctl("add-flow %s priority=100,in_port=%s,action=%s"
% (ps_name, port_no, patch_no))
ovs_ofctl("add-flow %s priority=100,in_port=%s,action=%s"
% (ps_name, patch_no, port_no))
# Create a logical_bindings_stats record.
if not vlan_:
vlan_ = "0"
vtep_ctl("set physical_port %s vlan_stats:%s=@stats -- "
"--id=@stats create logical_binding_stats packets_from_local=0"
% (pp_name, vlan_))
ls.add_lbinding(lbinding)
Bindings[binding] = ls.name
def del_binding(binding, ls):
vlog.info("removing binding %s" % binding)
vlan, pp_name = binding.split("-", 1)
pbinding = binding + "-p"
lbinding = binding + "-l"
port_no = ovs_vsctl("get Interface %s ofport" % pp_name)
patch_no = ovs_vsctl("get Interface %s ofport" % pbinding)
vlan_ = vlan.lstrip('0')
if vlan_:
ovs_ofctl("del-flows %s priority=200,in_port=%s,dl_vlan=%s"
% (ps_name, port_no, vlan_))
ovs_ofctl("del-flows %s priority=200,in_port=%s"
% (ps_name, patch_no))
else:
ovs_ofctl("--strict del-flows %s priority=100,in_port=%s"
% (ps_name, port_no))
ovs_ofctl("--strict del-flows %s priority=100,in_port=%s"
% (ps_name, patch_no))
ls.del_lbinding(lbinding)
# Destroy the patch port that connects the VLAN+port to the lswitch
ovs_vsctl("del-port %s %s -- del-port %s %s"
% (ps_name, pbinding, ls.short_name, lbinding))
# Remove the record that links vlan with stats in logical_binding_stats.
vtep_ctl("remove physical_port %s vlan_stats %s" % (pp_name, vlan))
del Bindings[binding]
def handle_physical():
# Gather physical ports except the patch ports we created
ovs_ports = ovs_vsctl("list-ports %s" % ps_name).split()
ovs_port_set = set([port for port in ovs_ports if port[-2:] != "-p"])
vtep_pp_set = set(vtep_ctl("list-ports %s" % ps_name).split())
for pp_name in ovs_port_set.difference(vtep_pp_set):
vlog.info("adding %s to %s" % (pp_name, ps_name))
vtep_ctl("add-port %s %s" % (ps_name, pp_name))
for pp_name in vtep_pp_set.difference(ovs_port_set):
vlog.info("deleting %s from %s" % (pp_name, ps_name))
vtep_ctl("del-port %s %s" % (ps_name, pp_name))
new_bindings = set()
for pp_name in vtep_pp_set:
binding_set = set(vtep_ctl("list-bindings %s %s"
% (ps_name, pp_name)).splitlines())
for b in binding_set:
vlan, ls_name = b.split()
if ls_name not in Lswitches:
Lswitches[ls_name] = Logical_Switch(ls_name, ps_name)
binding = "%s-%s" % (vlan, pp_name)
ls = Lswitches[ls_name]
new_bindings.add(binding)
if binding in Bindings:
if Bindings[binding] == ls_name:
continue
else:
del_binding(binding, Lswitches[Bindings[binding]])
add_binding(binding, ls)
dead_bindings = set(Bindings.keys()).difference(new_bindings)
for binding in dead_bindings:
ls_name = Bindings[binding]
ls = Lswitches[ls_name]
del_binding(binding, ls)
if not len(ls.ports):
ls.cleanup_ls()
ovs_vsctl("del-br %s" % Lswitches[ls_name].short_name)
vtep_ctl("clear-local-macs %s" % Lswitches[ls_name].name)
del Lswitches[ls_name]
def setup():
br_list = ovs_vsctl("list-br").split()
if (ps_name not in br_list):
ovs.util.ovs_fatal(0, "couldn't find OVS bridge %s" % ps_name, vlog)
global ps_type
ps_type = ovs_vsctl("get Bridge %s datapath_type" % ps_name).strip('"')
call_prog("vtep-ctl", ["set", "physical_switch", ps_name,
'description="OVS VTEP Emulator"'])
tunnel_ips = vtep_ctl("get physical_switch %s tunnel_ips"
% ps_name).strip('[]"').split(", ")
if len(tunnel_ips) != 1 or not tunnel_ips[0]:
ovs.util.ovs_fatal(0, "exactly one 'tunnel_ips' should be set", vlog)
global Tunnel_Ip
Tunnel_Ip = tunnel_ips[0]
ovs_ofctl("del-flows %s" % ps_name)
# Remove any logical bridges from the previous run
for br in br_list:
if ovs_vsctl("br-get-external-id %s vtep_logical_switch"
% br) == "true":
# Remove the remote side of any logical switch
ovs_ports = ovs_vsctl("list-ports %s" % br).split()
for port in ovs_ports:
port_type = ovs_vsctl("get Interface %s type"
% port).strip('"')
if port_type != "patch":
continue
peer = ovs_vsctl("get Interface %s options:peer"
% port).strip('"')
if (peer):
ovs_vsctl("del-port %s" % peer)
ovs_vsctl("del-br %s" % br)
if br == bfd_bridge:
bfd_ports = ovs_vsctl("list-ports %s" % bfd_bridge).split()
for port in bfd_ports:
remote_ip = ovs_vsctl("get interface %s options:remote_ip"
% port)
destroy_vtep_tunnel(remote_ip)
ovs_vsctl("del-br %s" % br)
if ps_type:
ovs_vsctl("add-br %s -- set Bridge %s datapath_type=%s"
% (bfd_bridge, bfd_bridge, ps_type))
else:
ovs_vsctl("add-br %s" % bfd_bridge)
# Remove local-mac entries from the previous run. Otherwise, if a vlan
# binding is removed while the emulator is *not* running, the corresponding
# local-mac entries are never cleaned up.
vtep_ls = set(vtep_ctl("list-ls").split())
for ls_name in vtep_ls:
vtep_ctl("clear-local-macs %s" % ls_name)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("ps_name", metavar="PS-NAME",
help="Name of physical switch.")
parser.add_argument("--root-prefix", metavar="DIR",
help="Use DIR as alternate root directory"
" (for testing).")
parser.add_argument("--version", action="version",
version="%s %s" % (ovs.util.PROGRAM_NAME, VERSION))
ovs.vlog.add_args(parser)
ovs.daemon.add_args(parser)
args = parser.parse_args()
ovs.vlog.handle_args(args)
ovs.daemon.handle_args(args)
global root_prefix
if args.root_prefix:
root_prefix = args.root_prefix
global ps_name
ps_name = args.ps_name
global verbose_args
if args.verbose:
verbose_args = ['-v' + arg for arg in args.verbose]
ovs.daemon.daemonize()
ovs.unixctl.command_register("exit", "", 0, 0, unixctl_exit, None)
error, unixctl = ovs.unixctl.server.UnixctlServer.create(None,
version=VERSION)
if error:
ovs.util.ovs_fatal(error, "could not create unixctl server", vlog)
setup()
while True:
unixctl.run()
if exiting:
break
handle_physical()
for ls_name, ls in Lswitches.items():
ls.run()
run_bfd()
poller = ovs.poller.Poller()
unixctl.wait(poller)
poller.timer_wait(1000)
poller.block()
unixctl.close()
if __name__ == '__main__':
try:
main()
except SystemExit:
# Let system.exit() calls complete normally
raise
except:
vlog.exception("traceback")
sys.exit(ovs.daemon.RESTART_EXIT_CODE)
Reference in New Issue View Git Blame Copy Permalink