def test_init(self):
"""Testing method init."""
# Testing with non-existant directory
directory = 'bogus'
os.environ['SWITCHMAP_CONFIGDIR'] = directory
with self.assertRaises(SystemExit):
configuration.Config()
# Testing with an empty directory
empty_directory = tempfile.mkdtemp()
os.environ['SWITCHMAP_CONFIGDIR'] = empty_directory
with self.assertRaises(SystemExit):
configuration.Config()
# Write bad_config to file
empty_config_file = ('%s/test_config.yaml') % (empty_directory)
with open(empty_config_file, 'w') as f_handle:
f_handle.write('')
# Create configuration object
config = configuration.Config()
with self.assertRaises(SystemExit):
config.log_file()
# Cleanup files in temp directories
_delete_files(directory)
def test_bind_port(self):
"""Testing method bind_port."""
# Testing bind_port with good_dictionary
# good key and key_value
result = self.config.bind_port()
self.assertEqual(result, 3000)
self.assertEqual(result, self.good_dict['main']['bind_port'])
# Set the environmental variable for the configuration directory
directory = tempfile.mkdtemp()
os.environ['SWITCHMAP_CONFIGDIR'] = directory
config_file = ('%s/test_config.yaml') % (directory)
# Testing bind_port with blank key and blank key_value
key = ''
key_value = ''
bad_config = ("""\
main:
%s %s
""") % (key, key_value)
bad_dict = yaml.load(bytes(bad_config, 'utf-8'))
# Write bad_config to file
with open(config_file, 'w') as f_handle:
yaml.dump(bad_dict, f_handle, default_flow_style=True)
# Create configuration object
config = configuration.Config()
with self.assertRaises(SystemExit):
config.bind_port()
# Testing bind_port with good key and blank key_value
key = 'bind_port:'
key_value = ''
bad_config = ("""\
main:
%s %s
""") % (key, key_value)
bad_dict = yaml.load(bytes(bad_config, 'utf-8'))
# Write bad_config to file
with open(config_file, 'w') as f_handle:
yaml.dump(bad_dict, f_handle, default_flow_style=True)
# Create configuration object
config = configuration.Config()
result = config.bind_port()
self.assertEqual(result, 7000)
# Cleanup files in temp directories
_delete_files(directory)
def test_log_directory(self):
"""Testing method log_directory."""
# Testing log_directory with temp directory
# Set the environmental variable for the configuration directory
directory = tempfile.mkdtemp()
os.environ['SWITCHMAP_CONFIGDIR'] = directory
config_file = ('%s/test_config.yaml') % (directory)
# Testing log_directory with blank key_value(filepath)
key = ''
key_value = ''
bad_config = ("""\
main:
%s %s
""") % (key, key_value)
bad_dict = yaml.load(bytes(bad_config, 'utf-8'))
with open(config_file, 'w') as f_handle:
yaml.dump(bad_dict, f_handle, default_flow_style=True)
# Create configuration object
config = configuration.Config()
with self.assertRaises(SystemExit):
config.log_directory()
# Cleanup files in temp directories
_delete_files(directory)
def poller(args):
"""Process 'show poller' commands.
Args:
args: Argparse arguments
Returns:
None
"""
if args.subqualifier == 'logs':
# Process logs
config = configuration.Config()
filename = config.log_file()
tail = input_output.File(filename)
tail.tail()
# Done
sys.exit(0)
elif args.subqualifier == 'status':
# Create agent objects
agent_poller = Agent(POLLER_EXECUTABLE)
# Get agent status
daemon_poller = AgentDaemon(agent_poller)
daemon_poller.status()
# Done
sys.exit(0)
# Show help if there are no matches
general.cli_help()
def check_user():
"""Check to make sure the user environment is correct.
Args:
None
Returns:
None
"""
# Initialize key variables
username = getpass.getuser()
config = configuration.Config()
configured_username = config.username()
# Prevent running as sudo user
check_sudo()
# Prevent others from running the script
if username != configured_username:
log_message = (
'You can only run this script as user \'{}\' '
'in the configuration file. Try running the command like this:\n'
'').format(configured_username)
print(log_message)
fixed_command = ('$ su -c \'{}\' {}\n'.format(' '.join(sys.argv[:]),
configured_username))
print(fixed_command)
sys.exit(2)
def __init__(self, searchstring):
"""Method initializing the class.
Args:
searchstring: search string to look for
Returns:
None
"""
# Initialize key variables
self._search = []
self.config = configuration.Config()
# Generate various possible strings that could be used for searches
self._search = _search_list(searchstring)
# Read ifindex file
self.ifindex_data = general.read_yaml_file(self.config.ifindex_file())
# Read host file
self.arp_data = general.read_yaml_file(self.config.arp_file())
# Read ifalias file
self.ifalias_data = general.read_yaml_file(self.config.ifalias_file())
def __init__(self, parent, child):
"""Method initializing the class.
Args:
parent: Name of parent daemon
child: Name of child daemon
Returns:
None
"""
# Initialize key variables
Agent.__init__(self, parent, child)
self.config = configuration.Config()
def main():
"""Initialize the class.
Args:
config: Configuration object
host: Hostname to process
Returns:
None
"""
# Initialize key variables
input_filename = sys.argv[1]
config = configuration.Config()
mac_addresses = {}
mac_hex_regex = (
'[0-9a-fA-F][0-9a-fA-F]-[0-9a-fA-F][0-9a-fA-F]-[0-9a-fA-F][0-9a-fA-F]')
regex = re.compile(r'^{}\s+.*?\(hex\)\s+.*?$'.format(mac_hex_regex))
# Ingest file
if os.path.isfile(input_filename) is False:
log_message = 'Filename {} not found.'.format(input_filename)
log.log2die(1025, log_message)
if input_filename.endswith('oui.txt') is False:
log_message = ('Filename {} is invalid. It must end with '
'\'oui.txt\'.'.format(input_filename))
log.log2die(1000, log_message)
with open(input_filename) as f_handle:
lines = f_handle.readlines()
# Read data
for line in lines:
# Create dictionary of mac addresses
if bool(regex.match(line)) is True:
(field1, field2) = line.split('(hex)')
mac_address = field1.strip().lower().replace('-', '')
company = field2.strip().replace(':', ' ')
mac_addresses[mac_address] = company
# Output the file to the metadata directory
output_file = config.mac_address_file()
if bool(mac_addresses) is True:
with open(output_file, 'w') as csvfile:
spamwriter = csv.writer(csvfile,
delimiter=':',
quoting=csv.QUOTE_NONE)
for key, value in sorted(mac_addresses.items()):
spamwriter.writerow([key, value])
def __init__(self):
"""Method initializing the class."""
# Define key variables
app_name = 'switchmap'
levels = {
'debug': logging.DEBUG,
'info': logging.INFO,
'warning': logging.WARNING,
'error': logging.ERROR,
'critical': logging.CRITICAL
}
# Get the logging directory
config = configuration.Config()
log_file = config.log_file()
config_log_level = config.log_level()
# Set logging level
if config_log_level in levels:
log_level = levels[config_log_level]
else:
log_level = levels['debug']
# create logger with app_name
self.logger_file = logging.getLogger(('%s_file') % (app_name))
self.logger_stdout = logging.getLogger(('%s_console') % (app_name))
# Set logging levels to file and stdout
self.logger_stdout.setLevel(log_level)
self.logger_file.setLevel(log_level)
# create file handler which logs even debug messages
file_handler = logging.FileHandler(log_file)
file_handler.setLevel(log_level)
# create console handler with a higher log level
stdout_handler = logging.StreamHandler()
stdout_handler.setLevel(log_level)
# create formatter and add it to the handlers
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler.setFormatter(formatter)
stdout_handler.setFormatter(formatter)
# add the handlers to the logger
self.logger_file.addHandler(file_handler)
self.logger_stdout.addHandler(stdout_handler)
def _hostnames():
"""Process 'show hostnames' commands.
Args:
None
Returns:
None
"""
config = configuration.Config()
_hostnames = config.hostnames()
for _hostname in _hostnames:
print(_hostname)
# Done
sys.exit(0)
def run(args):
"""Process 'test' command.
Args:
parser: Argparse parser
args: Argparse arguments
Returns:
None
"""
# Process the config
snmp_config = configuration.ConfigSNMP()
config = configuration.Config()
# Show help if no arguments provided
if args.qualifier is None:
general.cli_help()
# Test a single host
if bool(args.hostname) is True:
hostname = args.hostname
test_hostname(hostname, snmp_config)
sys.exit(0)
# Test all hosts
elif bool(args.all) is True:
hosts = config.hostnames()
if isinstance(hosts, list) is True:
if len(hosts) > 0:
for host in hosts:
test_hostname(host, snmp_config)
sys.exit(0)
else:
# No hosts found
log_message = 'No hosts found in configuration'
log.log2see(1038, log_message)
else:
# No hosts found
log_message = 'No hosts found in configuration'
log.log2see(1039, log_message)
# Show help if there are no matches
general.cli_help()
def _configuration():
"""Process 'show hostnames' commands.
Args:
None
Returns:
None
"""
config = configuration.Config()
contents = config.configuration()
print('')
pprint(contents, indent=2)
print('\n# Configuration read from directory: {}\n'
''.format(config.configuration_directory()))
# Done
sys.exit(0)
def get_hosts():
"""Get hosts listed in toplogy YAML files.
Args:
None
Returns:
hosts: List of hostnames
"""
# Read configuration
hosts = []
topology_directory = configuration.Config().topology_directory()
# Cycle through list of files in directory
for filename in os.listdir(topology_directory):
if filename.endswith('.yaml'):
hostname = filename[:-5]
hosts.append(hostname)
return sorted(hosts)
def __init__(self):
"""Function for intializing the class.
Args:
None
Returns:
None
"""
# Initialize key variables
running_username = getpass.getuser()
daemon_username = configuration.Config().username()
self.root_directory = general.root_directory()
switchmap_user_exists = True
self.switchmap_user = None
self.running_as_root = False
# Set the username we need to be running as
if running_username == 'root':
try:
# Get GID and UID for user
self.switchmap_user = daemon_username
self.gid = getpwnam(self.switchmap_user).pw_gid
self.uid = getpwnam(self.switchmap_user).pw_uid
except KeyError:
switchmap_user_exists = False
# Die if user doesn't exist
if switchmap_user_exists is False:
log_message = (
'User {} not found. Please try again.'
''.format(self.switchmap_user))
log.log2die_safe(1129, log_message)
else:
self.switchmap_user = daemon_username
# If running as the root user, then the switchmap user needs to exist
if running_username == 'root':
self.running_as_root = True
return
def api(args):
"""Process 'show api' commands.
Args:
args: Argparse arguments
Returns:
None
"""
if args.subqualifier == 'logs':
# Process logs
config = configuration.Config()
filename = config.web_log_file()
tail = input_output.File(filename)
tail.tail()
# Done
sys.exit(0)
elif args.subqualifier == 'status':
# Create agent objects
agent_gunicorn = Agent(API_GUNICORN_AGENT)
agent_api = AgentAPI(API_EXECUTABLE, API_GUNICORN_AGENT)
# Get agent status
daemon_gunicorn = AgentDaemon(agent_gunicorn)
daemon_gunicorn.status()
daemon_api = AgentDaemon(agent_api)
daemon_api.status()
# Done
sys.exit(0)
# Show help if there are no matches
general.cli_help()
# Do library imports
from switchmap.utils import configuration
# Create global variables used by all applications
CONFIG = configuration.Config()
CONFIG_SNMP = configuration.ConfigSNMP()
# Create global variables for the API
SITE_PREFIX = '/switchmap-ng'
API_PREFIX = '{}/api/v1'.format(SITE_PREFIX)
API_STATIC_FOLDER = 'static/default'
API_TEMPLATE_FOLDER = 'templates/default'
API_EXECUTABLE = 'switchmap-ng-api'
API_GUNICORN_AGENT = 'switchmap-ng-gunicorn'
POLLER_EXECUTABLE = 'switchmap-ng-poller'
class TestConfig(unittest.TestCase):
"""Checks all functions and methods."""
#########################################################################
# General object setup
#########################################################################
random_string = ''.join([
random.choice(string.ascii_letters + string.digits) for n in range(9)
])
log_directory = tempfile.mkdtemp()
cache_directory = tempfile.mkdtemp()
good_config = ("""\
main:
log_directory: %s
cache_directory: %s
agent_threads: 25
bind_port: 3000
hostnames:
- 192.168.1.1
- 192.168.1.2
- 192.168.1.3
- 192.168.1.4
listen_address: 0.0.0.0
log_level: debug
polling_interval: 20
""") % (log_directory, cache_directory)
# Convert good_config to dictionary
good_dict = yaml.load(bytes(good_config, 'utf-8'))
# Set the environmental variable for the configuration directory
directory = tempfile.mkdtemp()
os.environ['SWITCHMAP_CONFIGDIR'] = directory
config_file = ('%s/test_config.yaml') % (directory)
# Write good_config to file
with open(config_file, 'w') as f_handle:
yaml.dump(good_dict, f_handle, default_flow_style=True)
# Create configuration object
config = configuration.Config()
@classmethod
def tearDownClass(cls):
"""Post test cleanup."""
os.rmdir(cls.log_directory)
os.rmdir(cls.config.topology_directory())
os.rmdir(cls.config.idle_directory())
os.rmdir(cls.cache_directory)
os.remove(cls.config_file)
os.rmdir(cls.directory)
def test_init(self):
"""Testing method init."""
# Testing with non-existant directory
directory = 'bogus'
os.environ['SWITCHMAP_CONFIGDIR'] = directory
with self.assertRaises(SystemExit):
configuration.Config()
# Testing with an empty directory
empty_directory = tempfile.mkdtemp()
os.environ['SWITCHMAP_CONFIGDIR'] = empty_directory
with self.assertRaises(SystemExit):
configuration.Config()
# Write bad_config to file
empty_config_file = ('%s/test_config.yaml') % (empty_directory)
with open(empty_config_file, 'w') as f_handle:
f_handle.write('')
# Create configuration object
config = configuration.Config()
with self.assertRaises(SystemExit):
config.log_file()
# Cleanup files in temp directories
_delete_files(directory)
def test_log_file(self):
"""Testing method log_file."""
# Test the log_file with a good_dict
# good key and key_value
result = self.config.log_file()
self.assertEqual(result,
('%s/switchmap-ng.log') % (self.log_directory))
def test_web_log_file(self):
"""Testing method web_log_file ."""
# Testing web_log_file with a good dictionary.
result = self.config.web_log_file()
self.assertEqual(result,
('%s/switchmap-ng-api.log') % (self.log_directory))
def test_log_level(self):
"""Testing method log_level."""
# Tesing with a good_dictionary
# good key and good key_value
result = self.config.log_level()
self.assertEqual(result, 'debug')
self.assertEqual(result, self.good_dict['main']['log_level'])
# Set the environmental variable for the configuration directory
directory = tempfile.mkdtemp()
os.environ['SWITCHMAP_CONFIGDIR'] = directory
config_file = ('%s/test_config.yaml') % (directory)
# Testing log_level with blank key and blank key_value
key = ''
key_value = ''
bad_config = ("""\
main:
%s %s
""") % (key, key_value)
bad_dict = yaml.load(bytes(bad_config, 'utf-8'))
# Write bad_config to file
with open(config_file, 'w') as f_handle:
yaml.dump(bad_dict, f_handle, default_flow_style=True)
# Create configuration object
config = configuration.Config()
with self.assertRaises(SystemExit):
config.log_level()
# Testing log_level with good key and blank key_value
key = 'log_level:'
key_value = ''
bad_config = ("""\
main:
%s %s
""") % (key, key_value)
bad_dict = yaml.load(bytes(bad_config, 'utf-8'))
# Write bad_config to file
with open(config_file, 'w') as f_handle:
yaml.dump(bad_dict, f_handle, default_flow_style=True)
# Create configuration object
config = configuration.Config()
with self.assertRaises(SystemExit):
config.log_level()
# Cleanup files in temp directories
_delete_files(directory)
def test_cache_directory(self):
"""Testing method cache_directory."""
# Testing cache_directory with temp directory
# Set the environmental variable for the configuration directory
directory = tempfile.mkdtemp()
os.environ['SWITCHMAP_CONFIGDIR'] = directory
config_file = ('%s/test_config.yaml') % (directory)
# Testing cache_directory with blank key_value(filepath)
key = ''
key_value = ''
bad_config = ("""\
main:
%s %s
""") % (key, key_value)
bad_dict = yaml.load(bytes(bad_config, 'utf-8'))
with open(config_file, 'w') as f_handle:
yaml.dump(bad_dict, f_handle, default_flow_style=True)
# Create configuration object
config = configuration.Config()
with self.assertRaises(SystemExit):
config.cache_directory()
# Cleanup files in temp directories
_delete_files(directory)
def test_agent_threads(self):
"""Testing method agent_threads."""
# Testing agent_threads with good_dict
# good key and key_value
result = self.config.agent_threads()
# Get CPU cores
cores = multiprocessing.cpu_count()
desired_max_threads = max(1, cores - 1)
# We don't want a value that's too big that the CPU cannot cope
expected = min(result, desired_max_threads)
self.assertEqual(result, expected)
def test_polling_interval(self):
"""Testing method polling_interval."""
# Testing polling_interval with good_dictionary
# good key and key_value
result = self.config.polling_interval()
self.assertEqual(result, 20)
self.assertEqual(result, self.good_dict['main']['polling_interval'])
# Set the environmental variable for the configuration directory
directory = tempfile.mkdtemp()
os.environ['SWITCHMAP_CONFIGDIR'] = directory
config_file = ('%s/test_config.yaml') % (directory)
# Testing polling_interval with blank key and blank key_value
key = ''
key_value = ''
bad_config = ("""\
main:
%s %s
""") % (key, key_value)
bad_dict = yaml.load(bytes(bad_config, 'utf-8'))
# Write bad_config to file
with open(config_file, 'w') as f_handle:
yaml.dump(bad_dict, f_handle, default_flow_style=True)
# Create configuration object
config = configuration.Config()
with self.assertRaises(SystemExit):
config.polling_interval()
# Testing polling_interval with good key and blank key_value
key = 'polling_interval:'
key_value = ''
bad_config = ("""\
main:
%s %s
""") % (key, key_value)
bad_dict = yaml.load(bytes(bad_config, 'utf-8'))
# Write bad_config to file
with open(config_file, 'w') as f_handle:
yaml.dump(bad_dict, f_handle, default_flow_style=True)
# Create configuration object
config = configuration.Config()
result = config.polling_interval()
self.assertEqual(result, 86400)
# Cleanup files in temp directories
_delete_files(directory)
def test_bind_port(self):
"""Testing method bind_port."""
# Testing bind_port with good_dictionary
# good key and key_value
result = self.config.bind_port()
self.assertEqual(result, 3000)
self.assertEqual(result, self.good_dict['main']['bind_port'])
# Set the environmental variable for the configuration directory
directory = tempfile.mkdtemp()
os.environ['SWITCHMAP_CONFIGDIR'] = directory
config_file = ('%s/test_config.yaml') % (directory)
# Testing bind_port with blank key and blank key_value
key = ''
key_value = ''
bad_config = ("""\
main:
%s %s
""") % (key, key_value)
bad_dict = yaml.load(bytes(bad_config, 'utf-8'))
# Write bad_config to file
with open(config_file, 'w') as f_handle:
yaml.dump(bad_dict, f_handle, default_flow_style=True)
# Create configuration object
config = configuration.Config()
with self.assertRaises(SystemExit):
config.bind_port()
# Testing bind_port with good key and blank key_value
key = 'bind_port:'
key_value = ''
bad_config = ("""\
main:
%s %s
""") % (key, key_value)
bad_dict = yaml.load(bytes(bad_config, 'utf-8'))
# Write bad_config to file
with open(config_file, 'w') as f_handle:
yaml.dump(bad_dict, f_handle, default_flow_style=True)
# Create configuration object
config = configuration.Config()
result = config.bind_port()
self.assertEqual(result, 7000)
# Cleanup files in temp directories
_delete_files(directory)
def test_idle_directory(self):
"""Testing function idle_directory."""
# Verify that directory exists
result = self.config.idle_directory()
self.assertEqual(os.path.exists(result), True)
self.assertEqual(os.path.isdir(result), True)
# Doesn't fail because directory now exists
result = self.config.idle_directory()
expected = ('%s/idle') % (self.good_dict['main']['cache_directory'])
self.assertEqual(result, expected)
def test_topology_directory(self):
"""Testing function topology_directory."""
# Verify that directory exists
result = self.config.topology_directory()
self.assertEqual(os.path.exists(result), True)
self.assertEqual(os.path.isdir(result), True)
# Doesn't fail because directory now exists
result = self.config.topology_directory()
expected = ('%s/topology') % (
self.good_dict['main']['cache_directory'])
self.assertEqual(result, expected)
def test_topology_device_file(self):
"""Testing function topology_device_file."""
# Recreate the path to the device file
result = self.config.topology_device_file(self.random_string)
expected = ('%s/%s.yaml') % (self.config.topology_directory(),
self.random_string)
self.assertEqual(result, expected)
def test_hostnames(self):
"""Testing function hostnames."""
# Test expected versus returned values
result = self.config.hostnames()
expected = sorted(self.good_dict['main']['hostnames'])
self.assertEqual(result, expected)
def test_log_directory(self):
"""Testing method log_directory."""
# Testing log_directory with temp directory
# Set the environmental variable for the configuration directory
directory = tempfile.mkdtemp()
os.environ['SWITCHMAP_CONFIGDIR'] = directory
config_file = ('%s/test_config.yaml') % (directory)
# Testing log_directory with blank key_value(filepath)
key = ''
key_value = ''
bad_config = ("""\
main:
%s %s
""") % (key, key_value)
bad_dict = yaml.load(bytes(bad_config, 'utf-8'))
with open(config_file, 'w') as f_handle:
yaml.dump(bad_dict, f_handle, default_flow_style=True)
# Create configuration object
config = configuration.Config()
with self.assertRaises(SystemExit):
config.log_directory()
# Cleanup files in temp directories
_delete_files(directory)
