#!/usr/bin/env python3
###############################################################################
# Copyright (c) 2017 Koren Lev (Cisco Systems), Yaron Yogev (Cisco Systems) #
# and others #
# #
# All rights reserved. This program and the accompanying materials #
# are made available under the terms of the Apache License, Version 2.0 #
# which accompanies this distribution, and is available at #
# http://www.apache.org/licenses/LICENSE-2.0 #
###############################################################################
# Scan an object and insert/update in the inventory
# phase 2: either scan default environment, or scan specific object
import argparse
import sys
from discover.configuration import Configuration
from discover.fetcher import Fetcher
from discover.scan_error import ScanError
from discover.scanner import Scanner
from monitoring.setup.monitoring_setup_manager import MonitoringSetupManager
from utils.constants import EnvironmentFeatures
from utils.mongo_access import MongoAccess
from utils.exceptions import ScanArgumentsError
from utils.inventory_mgr import InventoryMgr
from utils.ssh_connection import SshConnection
from utils.util import setup_args
class ScanPlan:
"""
@DynamicAttrs
"""
# Each tuple of COMMON_ATTRIBUTES consists of:
# attr_name, arg_name and def_key
#
# attr_name - name of class attribute to be set
# arg_name - corresponding name of argument (equal to attr_name if not set)
# def_key - corresponding key in DEFAULTS (equal to attr_name if not set)
COMMON_ATTRIBUTES = (("loglevel",),
("inventory_only",),
("links_only",),
("cliques_only",),
("monitoring_setup_only",),
("clear",),
("clear_all",),
("object_type", "type", "type"),
("env",),
("object_id", "id", "env"),
("parent_id",),
("type_to_scan", "parent_type", "parent_type"),
("id_field",),
("scan_self",),
("child_type", "type", "type"))
def __init__(self, args=None):
self.obj = None
self.scanner_type = None
self.args = args
for attribute in self.COMMON_ATTRIBUTES:
setattr(self, attribute[0], None)
if isinstance(args, dict):
self._init_from_dict()
else:
self._init_from_args()
self._validate_args()
def _validate_args(self):
errors = []
if (self.inventory_only and self.links_only) \
or (self.inventory_only and self.cliques_only) \
or (self.links_only and self.cliques_only):
errors.append("Only one of (inventory_only, links_only, "
"cliques_only) can be True.")
if errors:
raise ScanArgumentsError("\n".join(errors))
def _set_arg_from_dict(self, attribute_name, arg_name=None,
default_key=None):
default_attr = default_key if default_key else attribute_name
setattr(self, attribute_name,
self.args.get(arg_name if arg_name else attribute_name,
ScanController.DEFAULTS[default_attr]))
def _set_arg_from_cmd(self, attribute_name, arg_name=None):
setattr(self,
attribute_name,
getattr(self.args, arg_name if arg_name else attribute_name))
def _set_arg_from_form(self, attribute_name, arg_name=None,
default_key=None):
default_attr = default_key if default_key else attribute_name
setattr(self,
attribute_name,
self.args.getvalue(arg_name if arg_name else attribute_name,
ScanController.DEFAULTS[default_attr]))
def _init_from_dict(self):
for arg in self.COMMON_ATTRIBUTES:
self._set_arg_from_dict(*arg)
self.child_id = None
def _init_from_args(self):
for arg in self.COMMON_ATTRIBUTES:
self._set_arg_from_cmd(*arg[:2])
self.child_id = None
class ScanController(Fetcher):
DEFAULTS = {
"env": "",
"mongo_config": "",
"type": "",
"inventory": "inventory",
"scan_self": False,
"parent_id": "",
"parent_type": "",
"id_field": "id",
"loglevel": "INFO",
"inventory_only": False,
"links_only": False,
"cliques_only": False,
"monitoring_setup_only": False,
"clear": False,
"clear_all": False
}
def __init__(self):
super().__init__()
self.conf = None
self.inv = None
def get_args(self):
# try to read scan plan from command line parameters
parser = argparse.ArgumentParser()
parser.add_argument("-m", "--mongo_config", nargs="?", type=str,
default=self.DEFAULTS["mongo_config"],
help="name of config file " +
"with MongoDB server access details")
parser.add_argument("-e", "--env", nargs="?", type=str,
default=self.DEFAULTS["env"],
help="name of environment to scan \n"
"(default: " + self.DEFAULTS["env"] + ")")
parser.add_argument("-t", "--type", nargs="?", type=str,
default=self.DEFAULTS["type"],
help="type of object to scan \n"
"(default: environment)")
parser.add_argument("-y", "--inventory", nargs="?", type=str,
default=self.DEFAULTS["inventory"],
help="name of inventory collection \n"
"(default: 'inventory')")
parser.add_argument("-s", "--scan_self", action="store_true",
help="scan changes to a specific object \n"
"(default: False)")
parser.add_argument("-i", "--id", nargs="?", type=str,
default=self.DEFAULTS["env"],
help="ID of object to scan (when scan_self=true)")
parser.add_argument("-p", "--parent_id", nargs="?", type=str,
default=self.DEFAULTS["parent_id"],
help="ID of parent object (when scan_self=true)")
parser.add_argument("-a", "--parent_type", nargs="?", type=str,
default=self.DEFAULTS["parent_type"],
help="type of parent object (when scan_self=true)")
parser.add_argument("-f", "--id_field", nargs="?", type=str,
default=self.DEFAULTS["id_field"],
help="name of ID field (when scan_self=true) \n"
"(default: 'id', use 'name' for projects)")
parser.add_argument("-l", "--loglevel", nargs="?", type=str,
default=self.DEFAULTS["loglevel"],
help="logging level \n(default: '{}')"
.format(self.DEFAULTS["loglevel"]))
parser.add_argument("--clear", action="store_true",
help="clear all data related to "
"the specified environment prior to scanning\n"
"(default: False)")
parser.add_argument("--clear_all", action="store_true",
help="clear all data prior to scanning\n"
"(default: False)")
parser.add_argument("--monitoring_setup_only", action="store_true",
help="do only monitoring setup deployment \n"
"(default: False)")
# At most one of these arguments may be present
scan_only_group = parser.add_mutually_exclusive_group()
scan_only_group.add_argument("--inventory_only", action="store_true",
help="do only scan to inventory\n" +
"(default: False)")
scan_only_group.add_argument("--links_only", action="store_true",
help="do only links creation \n" +
"(default: False)")
scan_only_group.add_argument("--cliques_only", action="store_true",
help="do only cliques creation \n" +
"(default: False)")
return parser.parse_args()
def get_scan_plan(self, args):
# PyCharm type checker can't reliably check types of document
# noinspection PyTypeChecker
return self.prepare_scan_plan(ScanPlan(args))
def prepare_scan_plan(self, plan):
# Find out object type if not specified in arguments
if not plan.object_type:
if not plan.object_id:
plan.object_type = "environment"
else:
# If we scan a specific object, it has to exist in db
scanned_object = self.inv.get_by_id(plan.env, plan.object_id)
if not scanned_object:
exc_msg = "No object found with specified id: '{}'" \
.format(plan.object_id)
raise ScanArgumentsError(exc_msg)
plan.object_type = scanned_object["type"]
plan.parent_id = scanned_object["parent_id"]
plan.type_to_scan = scanned_object["parent_type"]
class_module = plan.object_type
if not plan.scan_self:
plan.scan_self = plan.object_type != "environment"
plan.object_type = plan.object_type.title().replace("_", "")
if not plan.scan_self:
plan.child_type = None
else:
plan.child_id = plan.object_id
plan.object_id = plan.parent_id
if plan.type_to_scan.endswith("_folder"):
class_module = plan.child_type + "s_root"
else:
class_module = plan.type_to_scan
plan.object_type = class_module.title().replace("_", "")
if class_module == "environment":
plan.obj = {"id": plan.env}
else:
# fetch object from inventory
obj = self.inv.get_by_id(plan.env, plan.object_id)
if not obj:
raise ValueError("No match for object ID: {}"
.format(plan.object_id))
plan.obj = obj
plan.scanner_type = "Scan" + plan.object_type
return plan
def run(self, args: dict = None):
args = setup_args(args, self.DEFAULTS, self.get_args)
# After this setup we assume args dictionary has all keys
# defined in self.DEFAULTS
try:
MongoAccess.set_config_file(args['mongo_config'])
self.inv = InventoryMgr()
self.inv.set_collections(args['inventory'])
self.conf = Configuration()
except FileNotFoundError as e:
return False, 'Mongo configuration file not found: {}'\
.format(str(e))
scan_plan = self.get_scan_plan(args)
if scan_plan.clear or scan_plan.clear_all:
self.inv.clear(scan_plan)
self.conf.log.set_loglevel(scan_plan.loglevel)
env_name = scan_plan.env
self.conf.use_env(env_name)
# generate ScanObject Class and instance.
scanner = Scanner()
scanner.set_env(env_name)
scanner.found_errors[env_name] = False
# decide what scanning operations to do
inventory_only = scan_plan.inventory_only
links_only = scan_plan.links_only
cliques_only = scan_plan.cliques_only
monitoring_setup_only = scan_plan.monitoring_setup_only
run_all = False if inventory_only or links_only or cliques_only \
or monitoring_setup_only else True
# setup monitoring server
monitoring = \
self.inv.is_feature_supported(env_name,
EnvironmentFeatures.MONITORING)
if monitoring:
self.inv.monitoring_setup_manager = \
MonitoringSetupManager(env_name)
self.inv.monitoring_setup_manager.server_setup()
# do the actual scanning
try:
if inventory_only or run_all:
scanner.run_scan(
scan_plan.scanner_type,
scan_plan.obj,
scan_plan.id_field,
scan_plan.child_id,
scan_plan.child_type)
if links_only or run_all:
scanner.scan_links()
if cliques_only or run_all:
scanner.scan_cliques()
if monitoring:
if monitoring_setup_only:
self.inv.monitoring_setup_manager.simulate_track_changes()
if not (inventory_only or links_only or cliques_only):
scanner.deploy_monitoring_setup()
except ScanError as e:
return False, "scan error: " + str(e)
SshConnection.disconnect_all()
status = 'ok' if not scanner.found_errors.get(env_name, False) \
else 'errors detected'
self.log.info('Scan completed, status: {}'.format(status))
return True, status
if __name__ == '__main__':
scan_manager = ScanController()
ret, msg = scan_manager.run()
if not ret:
scan_manager.log.error(msg)
sys.exit(0 if ret else 1)