"""Implement configuration file parsing."""
# Copyright (C) 2015 Brad Cowie, Christopher Lorier and Joe Stringer.
# Copyright (C) 2015 Research and Education Advanced Network New Zealand Ltd.
# Copyright (C) 2015--2018 The Contributors
#
# 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.
import collections
import re
from faucet import config_parser_util
from faucet.acl import ACL
from faucet.conf import test_config_condition, InvalidConfigError
from faucet.dp import DP
from faucet.meter import Meter
from faucet.port import Port
from faucet.router import Router
from faucet.vlan import VLAN
from faucet.watcher_conf import WatcherConf
V2_TOP_CONFS = (
'acls',
'dps',
'meters',
'routers',
'vlans')
[docs]def dp_parser(config_file, logname):
"""Parse a config file into DP configuration objects with hashes of config include/files."""
conf = config_parser_util.read_config(config_file, logname)
config_hashes = None
dps = None
test_config_condition(conf is None, 'Config file is empty')
test_config_condition(not isinstance(conf, dict), 'Config file does not have valid syntax')
version = conf.pop('version', 2)
test_config_condition(version != 2, 'Only config version 2 is supported')
config_hashes, dps = _config_parser_v2(config_file, logname)
test_config_condition(dps is None, 'no DPs are not defined')
return config_hashes, dps
def _get_vlan_by_key(dp_id, vlan_key, vlans):
test_config_condition(not isinstance(vlan_key, (str, int)), (
'VLAN key must not be type %s' % type(vlan_key)))
if vlan_key in vlans:
return vlans[vlan_key]
for vlan in vlans.values():
if vlan_key == str(vlan.vid):
return vlan
# Create VLAN with VID, if not defined.
return vlans.setdefault(vlan_key, VLAN(vlan_key, dp_id))
def _dp_parse_port(dp_id, port_key, port_conf, vlans):
def _dp_parse_native_port_vlan():
if port.native_vlan is not None:
vlan = _get_vlan_by_key(dp_id, port.native_vlan, vlans)
port.native_vlan = vlan
def _dp_parse_tagged_port_vlans():
if port.tagged_vlans:
port_tagged_vlans = [
_get_vlan_by_key(dp_id, vlan_key, vlans) for vlan_key in port.tagged_vlans]
port.tagged_vlans = port_tagged_vlans
port = Port(port_key, dp_id, port_conf)
test_config_condition(str(port_key) not in (str(port.number), port.name), (
'Port key %s match port name or port number' % port_key))
_dp_parse_native_port_vlan()
_dp_parse_tagged_port_vlans()
return port
def _dp_add_ports(dp, dp_conf, dp_id, vlans):
ports_conf = dp_conf.get('interfaces', {})
port_ranges_conf = dp_conf.get('interface_ranges', {})
# as users can config port VLAN by using VLAN name, we store vid in
# Port instance instead of VLAN name for data consistency
test_config_condition(not isinstance(ports_conf, dict), (
'Invalid syntax in interface config'))
test_config_condition(not isinstance(port_ranges_conf, dict), (
'Invalid syntax in interface ranges config'))
def _map_port_num_to_port(ports_conf):
port_num_to_port_conf = {}
for port_key, port_conf in ports_conf.items():
test_config_condition(not isinstance(port_conf, dict), 'Invalid syntax in port config')
port_num = port_conf.get('number', port_key)
try:
port_num_to_port_conf[port_num] = (port_key, port_conf)
except TypeError:
raise InvalidConfigError('Invalid syntax in port config')
return port_num_to_port_conf
def _parse_port_ranges(port_ranges_conf, port_num_to_port_conf):
for port_range, port_conf in port_ranges_conf.items():
# port range format: 1-6 OR 1-6,8-9 OR 1-3,5,7-9
test_config_condition(not isinstance(port_conf, dict), 'Invalid syntax in port config')
port_nums = set()
if 'number' in port_conf:
del port_conf['number']
for range_ in re.findall(r'(\d+-\d+)', str(port_range)):
start_num, end_num = [int(num) for num in range_.split('-')]
test_config_condition(start_num >= end_num, (
'Incorrect port range (%d - %d)' % (start_num, end_num)))
port_nums.update(range(start_num, end_num + 1))
port_range = re.sub(range_, '', port_range)
other_nums = [int(p) for p in re.findall(r'\d+', str(port_range))]
port_nums.update(other_nums)
test_config_condition(not port_nums, 'interface-ranges contain invalid config')
for port_num in port_nums:
if port_num in port_num_to_port_conf:
# port range config has lower priority than individual port config
for attr, value in port_conf.items():
port_num_to_port_conf[port_num][1].setdefault(attr, value)
else:
port_num_to_port_conf[port_num] = (port_num, port_conf)
port_num_to_port_conf = _map_port_num_to_port(ports_conf)
_parse_port_ranges(port_ranges_conf, port_num_to_port_conf)
for port_num, port_conf in port_num_to_port_conf.values():
port = _dp_parse_port(dp_id, port_num, port_conf, vlans)
dp.add_port(port)
dp.reset_refs(vlans=vlans)
def _parse_dp(dp_key, dp_conf, acls_conf, meters_conf, routers_conf, vlans_conf):
test_config_condition(not isinstance(dp_conf, dict), '')
dp = DP(dp_key, dp_conf.get('dp_id', None), dp_conf)
test_config_condition(dp.name != dp_key, (
'DP key %s and DP name must match' % dp_key))
dp_id = dp.dp_id
vlans = {}
vids = set()
for vlan_key, vlan_conf in vlans_conf.items():
vlan = VLAN(vlan_key, dp_id, vlan_conf)
test_config_condition(str(vlan_key) not in (str(vlan.vid), vlan.name), (
'VLAN %s key must match VLAN name or VLAN VID' % vlan_key))
test_config_condition(vlan.vid in vids, (
'VLAN VID %u multiply configured' % vlan.vid))
vlans[vlan_key] = vlan
vids.add(vlan.vid)
for acl_key, acl_conf in acls_conf.items():
acl = ACL(acl_key, dp_id, acl_conf)
dp.add_acl(acl_key, acl)
for router_key, router_conf in routers_conf.items():
router = Router(router_key, dp_id, router_conf)
dp.add_router(router_key, router)
for meter_key, meter_conf in meters_conf.items():
meter = Meter(meter_key, dp_id, meter_conf)
dp.meters[meter_key] = meter
_dp_add_ports(dp, dp_conf, dp_id, vlans)
return dp
def _dp_parser_v2(acls_conf, dps_conf, meters_conf,
routers_conf, vlans_conf):
dps = [_parse_dp(dp_key, dp_conf, acls_conf, meters_conf, routers_conf, vlans_conf)
for dp_key, dp_conf in dps_conf.items()]
for dp in dps:
dp.finalize_config(dps)
for dp in dps:
dp.resolve_stack_topology(dps)
router_ref_dps = collections.defaultdict(set)
for dp in dps:
for router in dp.routers.keys():
router_ref_dps[router].add(dp)
for router in routers_conf.keys():
test_config_condition(not router_ref_dps[router], (
'router %s configured but not used by any DP' % router))
return dps
def _config_parser_v2(config_file, logname):
config_path = config_parser_util.dp_config_path(config_file)
top_confs = {}
config_hashes = {}
dps = None
for top_conf in V2_TOP_CONFS:
top_confs[top_conf] = {}
if not config_parser_util.dp_include(
config_hashes, config_path, logname, top_confs):
raise InvalidConfigError('Error found while loading config file: %s' % config_path)
if not top_confs['dps']:
raise InvalidConfigError('DPs not configured in file: %s' % config_path)
dps = _dp_parser_v2(
top_confs['acls'],
top_confs['dps'],
top_confs['meters'],
top_confs['routers'],
top_confs['vlans'])
return (config_hashes, dps)
[docs]def get_config_for_api(valves):
"""Return config as dict for all DPs."""
config = {}
for i in V2_TOP_CONFS:
config[i] = {}
for valve in valves.values():
valve_conf = valve.get_config_dict()
for i in V2_TOP_CONFS:
if i in valve_conf:
config[i].update(valve_conf[i])
return config
[docs]def watcher_parser(config_file, logname, prom_client):
"""Return Watcher instances from config."""
conf = config_parser_util.read_config(config_file, logname)
return _watcher_parser_v2(conf, logname, prom_client)
def _parse_dps_for_watchers(conf, logname):
dps = {}
if 'faucet_configs' in conf:
for faucet_file in conf['faucet_configs']:
_, dp_list = dp_parser(faucet_file, logname)
if dp_list:
for dp in dp_list:
dps[dp.name] = dp
if 'faucet' in conf:
faucet_conf = conf['faucet']
acls = faucet_conf.get('acls', {})
fct_dps = faucet_conf.get('dps', {})
meters = faucet_conf.get('meters', {})
routers = faucet_conf.get('routers', {})
vlans = faucet_conf.get('vlans', {})
for dp in _dp_parser_v2(acls, fct_dps, meters, routers, vlans):
dps[dp.name] = dp
if not dps:
raise InvalidConfigError(
'Gauge configured without any FAUCET configuration')
return dps
def _watcher_parser_v2(conf, logname, prom_client):
logger = config_parser_util.get_logger(logname)
if conf is None:
conf = {}
dps = _parse_dps_for_watchers(conf, logname)
dbs = conf.pop('dbs')
result = []
# pylint: disable=fixme
for watcher_name, watcher_conf in conf['watchers'].items():
if watcher_conf.get('all_dps', False):
watcher_dps = dps.keys()
else:
watcher_dps = watcher_conf['dps']
# Watcher config has a list of DPs, but actually a WatcherConf is
# created for each DP.
# TODO: refactor watcher_conf as a container.
for dp_name in watcher_dps:
if dp_name not in dps:
logger.error('DP %s in Gauge but not configured in FAUCET', dp_name)
continue
dp = dps[dp_name]
if 'dbs' in watcher_conf:
watcher_dbs = watcher_conf['dbs']
elif 'db' in watcher_conf:
watcher_dbs = [watcher_conf['db']]
else:
raise InvalidConfigError('Watcher configured without DB')
for db in watcher_dbs:
watcher = WatcherConf(watcher_name, dp.dp_id, watcher_conf, prom_client)
watcher.add_db(dbs[db])
watcher.add_dp(dp)
result.append(watcher)
return result