def __init__(self, *args, **kwargs):
super(Faucet, self).__init__(*args, **kwargs)
# There doesnt seem to be a sensible method of getting command line
# options into ryu apps. Instead I am using the environment variable
# FAUCET_CONFIG to allow this to be set, if it is not set it will
# default to valve.yaml
sysprefix = get_sys_prefix()
self.config_file = os.getenv(
'FAUCET_CONFIG', sysprefix + '/etc/ryu/faucet/faucet.yaml')
self.logfile = os.getenv(
'FAUCET_LOG', sysprefix + '/var/log/ryu/faucet/faucet.log')
self.exc_logfile = os.getenv(
'FAUCET_EXCEPTION_LOG',
sysprefix + '/var/log/ryu/faucet/faucet_exception.log')
# Set the signal handler for reloading config file
signal.signal(signal.SIGHUP, self.signal_handler)
# Create dpset object for querying Ryu's DPSet application
self.dpset = kwargs['dpset']
# Setup logging
self.logger = logging.getLogger(self.logname)
logger_handler = TimedRotatingFileHandler(
self.logfile,
when='midnight')
log_fmt = '%(asctime)s %(name)-6s %(levelname)-8s %(message)s'
logger_handler.setFormatter(
logging.Formatter(log_fmt, '%b %d %H:%M:%S'))
self.logger.addHandler(logger_handler)
self.logger.propagate = 0
self.logger.setLevel(logging.DEBUG)
# Set up separate logging for exceptions
exc_logger = logging.getLogger(self.exc_logname)
exc_logger_handler = logging.FileHandler(self.exc_logfile)
exc_logger_handler.setFormatter(
logging.Formatter(log_fmt, '%b %d %H:%M:%S'))
exc_logger.addHandler(exc_logger_handler)
exc_logger.propagate = 1
exc_logger.setLevel(logging.CRITICAL)
# Set up a valve object for each datapath
self.valves = {}
for dp in dp_parser(self.config_file, self.logname):
# pylint: disable=no-member
valve = valve_factory(dp)
if valve is None:
self.logger.error('Hardware type not supported for DP: %s' % dp.name)
else:
self.valves[dp.dp_id] = valve(dp, self.logname)
self.gateway_resolve_request_thread = hub.spawn(
self.gateway_resolve_request)
self.host_expire_request_thread = hub.spawn(
self.host_expire_request)
self.dp_bgp_speakers = {}
self.reset_bgp()
def __init__(self, *args, **kwargs):
super(Dashboard, self).__init__(*args, **kwargs)
self.config_file = os.getenv('GAUGE_CONFIG', '/etc/ryu/faucet/gauge.conf')
self.logger = self.create_logger()
self.dps = {}
with open(self.config_file, 'r') as config_file:
for dp_conf_file in config_file:
# config_file should be a list of faucet config filenames
# separated by linebreaks
dp = DP.parser(dp_conf_file.strip(), self.logname)
try:
dp.sanity_check()
self.valve = valve_factory(dp)
except AssertionError:
self.logger.exception(
"Error in config file {0}".format(dp_conf_file))
else:
self.dps[dp.dp_id] = dp
# Create dpset object for querying Ryu's DPSet application
self.dpset = kwargs['dpset']
# dict of polling threads:
# polling threads are indexed by dp_id and then by name
# eg: self.pollers[0x1]['port_stats']
self.pollers = {}
# dict of async event handlers
self.handlers = {}
self.redis_flush_thread = hub.spawn(self.redis_flush_request)
def _load_configs(self, new_config_file):
self.config_file = new_config_file
self.config_hashes, new_dps = dp_parser(
new_config_file, self.logname)
deleted_valve_dpids = (
set(list(self.valves.keys())) -
set([valve.dp_id for valve in new_dps]))
for new_dp in new_dps:
cold_start = True
if new_dp.dp_id in self.valves:
valve = self.valves[new_dp.dp_id]
cold_start, flowmods = valve.reload_config(new_dp)
self._send_flow_msgs(new_dp.dp_id, flowmods)
else:
# pylint: disable=no-member
valve_cl = valve_factory(new_dp)
if valve_cl is None:
self.logger.fatal('Could not configure %s', new_dp.name)
else:
valve = valve_cl(new_dp, self.logname)
self.valves[new_dp.dp_id] = valve
# pylint: disable=no-member
if cold_start:
self.metrics.faucet_config_reload_cold.labels(
dpid=hex(new_dp.dp_id)).inc()
else:
self.metrics.faucet_config_reload_warm.labels(
dpid=hex(new_dp.dp_id)).inc()
valve.update_config_metrics(self.metrics)
for deleted_valve_dpid in deleted_valve_dpids:
self.logger.info(
'Deleting de-configured %s', dpid_log(deleted_valve_dpid))
del self.valves[deleted_valve_dpid]
self._bgp.reset(self.valves, self.metrics)
def __init__(self, *args, **kwargs):
super(Faucet, self).__init__(*args, **kwargs)
# There doesnt seem to be a sensible method of getting command line
# options into ryu apps. Instead I am using the environment variable
# FAUCET_CONFIG to allow this to be set, if it is not set it will
# default to valve.yaml
self.config_file = os.getenv(
'FAUCET_CONFIG', '/etc/ryu/faucet/faucet.yaml')
self.logfile = os.getenv(
'FAUCET_LOG', '/var/log/ryu/faucet/faucet.log')
self.exc_logfile = os.getenv(
'FAUCET_EXCEPTION_LOG', '/var/log/ryu/faucet/faucet_exception.log')
# Set the signal handler for reloading config file
signal.signal(signal.SIGHUP, self.signal_handler)
# Create dpset object for querying Ryu's DPSet application
self.dpset = kwargs['dpset']
# Setup logging
self.logger = logging.getLogger(self.logname)
logger_handler = TimedRotatingFileHandler(
self.logfile,
when='midnight')
log_fmt = '%(asctime)s %(name)-6s %(levelname)-8s %(message)s'
logger_handler.setFormatter(
logging.Formatter(log_fmt, '%b %d %H:%M:%S'))
self.logger.addHandler(logger_handler)
self.logger.propagate = 0
self.logger.setLevel(logging.DEBUG)
# Set up separate logging for exceptions
exc_logger = logging.getLogger(self.exc_logname)
exc_logger_handler = logging.FileHandler(self.exc_logfile)
exc_logger_handler.setFormatter(
logging.Formatter(log_fmt, '%b %d %H:%M:%S'))
exc_logger.addHandler(exc_logger_handler)
exc_logger.propagate = 1
exc_logger.setLevel(logging.CRITICAL)
# Set up a valve object for each datapath
self.valves = {}
for dp in dp_parser(self.config_file, self.logname):
# pylint: disable=no-member
valve = valve_factory(dp)(dp, self.logname)
if valve is None:
self.logger.error('Hardware type not supported for DP: %s' % dp.name)
else:
self.valves[dp.dp_id] = valve
self.gateway_resolve_request_thread = hub.spawn(
self.gateway_resolve_request)
self.host_expire_request_thread = hub.spawn(
self.host_expire_request)
self.dp_bgp_speakers = {}
self.reset_bgp()
def __init__(self, *args, **kwargs):
super(Faucet, self).__init__(*args, **kwargs)
# There doesnt seem to be a sensible method of getting command line
# options into ryu apps. Instead I am using the environment variable
# FAUCET_CONFIG to allow this to be set, if it is not set it will
# default to valve.yaml
sysprefix = get_sys_prefix()
self.config_file = os.getenv(
'FAUCET_CONFIG', sysprefix + '/etc/ryu/faucet/faucet.yaml')
self.logfile = os.getenv(
'FAUCET_LOG', sysprefix + '/var/log/ryu/faucet/faucet.log')
self.exc_logfile = os.getenv(
'FAUCET_EXCEPTION_LOG',
sysprefix + '/var/log/ryu/faucet/faucet_exception.log')
# Set the signal handler for reloading config file
signal.signal(signal.SIGHUP, self.signal_handler)
# Create dpset object for querying Ryu's DPSet application
self.dpset = kwargs['dpset']
# Setup logging
self.logger = get_logger(
self.logname, self.logfile, logging.DEBUG, 0)
# Set up separate logging for exceptions
self.exc_logger = get_logger(
self.exc_logname, self.exc_logfile, logging.DEBUG, 1)
# Set up a valve object for each datapath
self.valves = {}
self.config_hashes, valve_dps = dp_parser(
self.config_file, self.logname)
for valve_dp in valve_dps:
# pylint: disable=no-member
valve = valve_factory(valve_dp)
if valve is None:
self.logger.error(
'Hardware type not supported for DP: %s', valve_dp.name)
else:
self.valves[valve_dp.dp_id] = valve(valve_dp, self.logname)
self.gateway_resolve_request_thread = hub.spawn(
self.gateway_resolve_request)
self.host_expire_request_thread = hub.spawn(
self.host_expire_request)
self.dp_bgp_speakers = {}
self._reset_bgp()
# Register to API
api = kwargs['faucet_api']
api._register(self)
self.send_event_to_observers(EventFaucetAPIRegistered())
def __init__(self, *args, **kwargs):
super(Faucet, self).__init__(*args, **kwargs)
# There doesnt seem to be a sensible method of getting command line
# options into ryu apps. Instead I am using the environment variable
# FAUCET_CONFIG to allow this to be set, if it is not set it will
# default to valve.yaml
sysprefix = get_sys_prefix()
self.config_file = os.getenv(
'FAUCET_CONFIG', sysprefix + '/etc/ryu/faucet/faucet.yaml')
self.logfile = os.getenv(
'FAUCET_LOG', sysprefix + '/var/log/ryu/faucet/faucet.log')
self.exc_logfile = os.getenv(
'FAUCET_EXCEPTION_LOG',
sysprefix + '/var/log/ryu/faucet/faucet_exception.log')
# Set the signal handler for reloading config file
signal.signal(signal.SIGHUP, self.signal_handler)
# Create dpset object for querying Ryu's DPSet application
self.dpset = kwargs['dpset']
# Setup logging
self.logger = get_logger(
self.logname, self.logfile, logging.DEBUG, 0)
# Set up separate logging for exceptions
self.exc_logger = get_logger(
self.exc_logname, self.exc_logfile, logging.DEBUG, 1)
# Set up a valve object for each datapath
self.valves = {}
self.config_hashes, valve_dps = dp_parser(
self.config_file, self.logname)
for valve_dp in valve_dps:
# pylint: disable=no-member
valve = valve_factory(valve_dp)
if valve is None:
self.logger.error(
'Hardware type not supported for DP: %s', valve_dp.name)
else:
self.valves[valve_dp.dp_id] = valve(valve_dp, self.logname)
self.gateway_resolve_request_thread = hub.spawn(
self.gateway_resolve_request)
self.host_expire_request_thread = hub.spawn(
self.host_expire_request)
self.dp_bgp_speakers = {}
self._reset_bgp()
# Register to API
api = kwargs['faucet_api']
api._register(self)
self.send_event_to_observers(EventFaucetAPIRegistered())
def __init__(self, *args, **kwargs):
super(Faucet, self).__init__(*args, **kwargs)
# There doesnt seem to be a sensible method of getting command line
# options into ryu apps. Instead I am using the environment variable
# FAUCET_CONFIG to allow this to be set, if it is not set it will
# default to valve.yaml
self.config_file = os.getenv(
'FAUCET_CONFIG', '/etc/opt/faucet/valve.yaml')
self.logfile = os.getenv(
'FAUCET_LOG', '/var/log/faucet/faucet.log')
self.exc_logfile = os.getenv(
'FAUCET_EXCEPTION_LOG', '/var/log/faucet/faucet_exception.log')
# Set the signal handler for reloading config file
signal.signal(signal.SIGHUP, self.signal_handler)
# Create dpset object for querying Ryu's DPSet application
self.dpset = kwargs['dpset']
# Setup logging
self.logger = logging.getLogger(self.logname)
logger_handler = TimedRotatingFileHandler(
self.logfile,
when='midnight')
log_fmt = '%(asctime)s %(name)-6s %(levelname)-8s %(message)s'
logger_handler.setFormatter(
logging.Formatter(log_fmt, '%b %d %H:%M:%S'))
self.logger.addHandler(logger_handler)
self.logger.propagate = 0
self.logger.setLevel(logging.DEBUG)
# Set up separate logging for exceptions
exc_logger = logging.getLogger(self.exc_logname)
exc_logger_handler = logging.FileHandler(self.exc_logfile)
exc_logger_handler.setFormatter(
logging.Formatter(log_fmt, '%b %d %H:%M:%S'))
exc_logger.addHandler(exc_logger_handler)
exc_logger.propagate = 1
exc_logger.setLevel(logging.CRITICAL)
# Parse config file
dp = DP.parser(self.config_file, self.logname)
if dp:
try:
dp.sanity_check()
except AssertionError:
self.logger.exception("Error in config file:")
# Load Valve
self.valve = valve_factory(dp)
if self.valve is None:
self.logger.error("Hardware type not supported")
def __init__(self, *args, **kwargs):
super(Faucet, self).__init__(*args, **kwargs)
# There doesnt seem to be a sensible method of getting command line
# options into ryu apps. Instead I am using the environment variable
# FAUCET_CONFIG to allow this to be set, if it is not set it will
# default to valve.yaml
self.config_file = os.getenv('FAUCET_CONFIG',
'/etc/opt/faucet/valve.yaml')
self.logfile = os.getenv('FAUCET_LOG', '/var/log/faucet/faucet.log')
self.exc_logfile = os.getenv('FAUCET_EXCEPTION_LOG',
'/var/log/faucet/faucet_exception.log')
# Set the signal handler for reloading config file
signal.signal(signal.SIGHUP, self.signal_handler)
# Create dpset object for querying Ryu's DPSet application
self.dpset = kwargs['dpset']
# Setup logging
self.logger = logging.getLogger(self.logname)
logger_handler = TimedRotatingFileHandler(self.logfile,
when='midnight')
log_fmt = '%(asctime)s %(name)-6s %(levelname)-8s %(message)s'
logger_handler.setFormatter(
logging.Formatter(log_fmt, '%b %d %H:%M:%S'))
self.logger.addHandler(logger_handler)
self.logger.propagate = 0
self.logger.setLevel(logging.DEBUG)
# Set up separate logging for exceptions
exc_logger = logging.getLogger(self.exc_logname)
exc_logger_handler = logging.FileHandler(self.exc_logfile)
exc_logger_handler.setFormatter(
logging.Formatter(log_fmt, '%b %d %H:%M:%S'))
exc_logger.addHandler(exc_logger_handler)
exc_logger.propagate = 1
exc_logger.setLevel(logging.CRITICAL)
dp = self.parse_config(self.config_file, self.logname)
self.valve = valve_factory(dp)
if self.valve is None:
self.logger.error("Hardware type not supported")
self.gateway_resolve_request_thread = hub.spawn(
self.gateway_resolve_request)
def _load_configs(self, new_config_file):
self.config_file = new_config_file
self.config_hashes, new_dps = dp_parser(new_config_file, self.logname)
if new_dps is None:
self.logger.error('new config bad - rejecting')
return
deleted_valve_dpids = (set(list(self.valves.keys())) -
set([valve.dp_id for valve in new_dps]))
for new_dp in new_dps:
dp_id = new_dp.dp_id
if dp_id in self.valves:
valve = self.valves[dp_id]
cold_start, flowmods = valve.reload_config(new_dp)
# pylint: disable=no-member
if flowmods:
self._send_flow_msgs(new_dp.dp_id, flowmods)
if cold_start:
self.metrics.faucet_config_reload_cold.labels(
dp_id=hex(dp_id)).inc()
else:
self.metrics.faucet_config_reload_warm.labels(
dp_id=hex(dp_id)).inc()
else:
# pylint: disable=no-member
valve_cl = valve_factory(new_dp)
if valve_cl is None:
self.logger.error('%s hardware %s must be one of %s',
new_dp.name, new_dp.hardware,
sorted(list(SUPPORTED_HARDWARE.keys())))
continue
else:
valve = valve_cl(new_dp, self.logname)
self.valves[dp_id] = valve
self.logger.info('Add new datapath %s', dpid_log(dp_id))
self.metrics.reset_dpid(dp_id)
valve.update_config_metrics(self.metrics)
for deleted_valve_dpid in deleted_valve_dpids:
self.logger.info('Deleting de-configured %s',
dpid_log(deleted_valve_dpid))
del self.valves[deleted_valve_dpid]
ryu_dp = self.dpset.get(deleted_valve_dpid)
if ryu_dp is not None:
ryu_dp.close()
self._bgp.reset(self.valves, self.metrics)
def check_config(conf_files):
logname = '/dev/null'
logger = logging.getLogger('%s.config' % logname)
logger_handler = logging.StreamHandler(stream=sys.stderr)
logger.addHandler(logger_handler)
logger.propagate = 0
logger.setLevel(logging.DEBUG)
for conf_file in conf_files:
parse_result = dp_parser(conf_file, logname)
if parse_result is None:
return False
else:
_, dps = parse_result
for dp in dps:
valve_dp = valve.valve_factory(dp)
if valve_dp is None:
return False
print((dp.to_conf()))
return True
