Current File : //snap/lxd/current/share/openvswitch/scripts/ovs-vtep
#! /usr/bin/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 in_port=%s,dl_vlan=%s,action=strip_vlan,%s"
% (ps_name, port_no, vlan_, patch_no))
ovs_ofctl("add-flow %s in_port=%s,action=mod_vlan_vid:%s,%s"
% (ps_name, patch_no, vlan_, port_no))
else:
ovs_ofctl("add-flow %s in_port=%s,action=%s"
% (ps_name, port_no, patch_no))
ovs_ofctl("add-flow %s 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 in_port=%s,dl_vlan=%s"
% (ps_name, port_no, vlan_))
ovs_ofctl("del-flows %s in_port=%s" % (ps_name, patch_no))
else:
ovs_ofctl("--strict del-flows %s in_port=%s" % (ps_name, port_no))
ovs_ofctl("--strict del-flows %s 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)
Mini Shell