import argparse import difflib import getpass import logging from pprint import pprint import colorlog import requests import termcolor import yaml from jinja2 import Template from core import connect_to_switch, sftp_read_file, sftp_write_file logger = logging.getLogger() def syntax_from_range(value, vlan_syntax=False): if value == []: return None value = set(value) prec = None syntax = "" in_range = False for i in value: if prec is None or prec != i - 1: if syntax == "": syntax = str(i) elif in_range: if vlan_syntax: syntax += "-{} {}".format(prec,i) else: syntax += "-{},{}".format(prec,i) in_range = False else: if vlan_syntax: syntax += " {}".format(i) else: syntax += ",{}".format(i) in_range = False elif i == max(value): syntax += "-{}".format(i) else: in_range = True prec = i if vlan_syntax: syntax += " " return syntax def range_from_syntax(value, vlan_syntax=False): if value is None: return [] ret_range = list() if vlan_syntax: value = str(value).split(" ") else: value = str(value).split(",") for v in value: v = v.split("-") if len(v) == 2: v = list(range(int(v[0]), int(v[1])+1)) elif len(v) == 1: v = [int(v[0])] else: raise RuntimeError("You fucked") ret_range += v return ret_range def gen_vlan(vlan_number, switch_config, dhcp_snooping_vlans): vlan_config = yaml.load(open("configs/vlans/{}.yml".format(vlan_number), "r"), yaml.Loader) vlan = { "name": vlan_config.get("name"), "tagged": list(), "untagged": list(), } if vlan_config.get("dhcp_snooping", True): dhcp_snooping_vlans.append(int(vlan_number)) if vlan_config.get("has_ip"): vlan["ip"] = dict() v4 = switch_config.get("ipv4-addr") v4_sub = switch_config.get("ipv4-subnet") if v4 is not None and v4_sub is not None: logger.debug("Adding {} {} to vlan {}".format(v4, v4_sub, vlan_number)) vlan["ip"]["addr"] = v4 vlan["ip"]["subnet"] = v4_sub v6 = switch_config.get("ipv6-addr") v6_sub = switch_config.get("ipv6-subnet") if v6 is not None and v6_sub is not None: logger.debug("Adding {}/{} to vlan {}".format(v6, v6_sub, vlan_number)) vlan["ip"]["addr6"] = v6 vlan["ip"]["subnet6"] = v6_sub if vlan["ip"] == {}: logger.critical("Missing IPs or subnets configurations for vlan {}".format(vlan_number)) raise RuntimeError() return vlan, dhcp_snooping_vlans def gen_interfaces(switch_config): dhcp_snooping_vlans = list() mac_based_ports = list() ra_guard_ports = list() ifaces_done = list() interfaces = list() vlans = dict() has_ip = False for iface, if_config in switch_config.get("interfaces").items(): if_profile = yaml.load(open("configs/profiles/{}.yml".format(if_config.get("profile"))), yaml.Loader) iface = range_from_syntax(iface) for iface_number in iface: if not if_profile.get("ignore_port", False): interface = { "number": iface_number, } generic = if_profile.get("generic_name", None) if generic is None: interface["name"] = if_config["name"] else: interface["name"] = "TODO {} {}".format(generic, iface_number) interface["mac_based"] = if_profile.get("mac_based", False) if interface["mac_based"]: mac_based_ports.append(iface_number) if if_profile.get("ra_guard", True): ra_guard_ports.append(iface_number) interface["addr_limit"] = if_profile.get("addr_limit", 5) interface["logoff"] = if_profile.get("logoff", 3600) interfaces.append(interface) ifaces_done.append(iface_number) for vlan in range_from_syntax(if_profile.get("vlans").get("untagged")): if vlans.get(vlan) is None: vlans[vlan], dhcp_snooping_vlans = gen_vlan(vlan, switch_config, dhcp_snooping_vlans) vlans[vlan]["untagged"].append(iface_number) for vlan in range_from_syntax(if_profile.get("vlans").get("tagged")): if vlans.get(vlan) is None: vlans[vlan], dhcp_snooping_vlans = gen_vlan(vlan, switch_config, dhcp_snooping_vlans) vlans[vlan]["tagged"].append(iface_number) ifaces_done = set(ifaces_done) # on reformatte les interfaces des vlans for vlan, v_conf in vlans.items(): vlans[vlan]["tagged"] = syntax_from_range(v_conf["tagged"]) vlans[vlan]["untagged"] = syntax_from_range(v_conf["untagged"]) if max(ifaces_done) != switch_config.get("nb_ports") or len(ifaces_done) != switch_config.get("nb_ports"): raise RuntimeError("Interfaces fucked") interfaces.sort(key=lambda x: x["number"]) return interfaces, vlans, mac_based_ports, ra_guard_ports, dhcp_snooping_vlans def get_header(old_config): header = "\n".join(old_config.split("\n")[:2]) return header def conf_from_dict(config_dict): with open("configs/config.j2", "r") as template_file: template = Template(template_file.read()) configuration = template.render(config_dict) return configuration def gen_conf(master_config, switch_config, header): interfaces, vlans, mac_based_ports, ra_guard_ports, dhcp_snooping_vlans = gen_interfaces(switch_config) config_dict = { "header": header, "hostname": switch_config.get("hostname"), "dhcp_servers": master_config.get("dhcp_servers"), "dhcpv6_servers": master_config.get("dhcpv6_servers"), "snmp_user": master_config.get("snmp_user"), "interfaces": interfaces, "vlans": vlans, "sntp": master_config.get("sntp_servers"), "ipv4_managers": master_config.get("managers_v4", {}), "ipv6_managers": master_config.get("managers_v6", {}), "dns": master_config.get("dns"), "location": switch_config["location"], "radius_servers": master_config.get("radius_servers"), "mac_based_ports": syntax_from_range(mac_based_ports), "ra_guard_ports": syntax_from_range(ra_guard_ports), "unauth_redirect": master_config.get("unauth_redirect"), "dhcp_snooping_vlans": syntax_from_range(dhcp_snooping_vlans, vlan_syntax=True), } return conf_from_dict(config_dict) def gen_conf_re2o(re2o_config, header): mgmt_utils = re2o_config.get("switchs_management_utils") ipv4_managers = dict() for m in mgmt_utils.get("subnet"): print(m) ipv4_managers[m.get("network")] = { "ip": m.get("network"), "subnet": m.get("netmask")} ipv6_managers = dict() # FUCK YOU ! subnet6 c'est pas une liste de subnets mais un seul subnet m = mgmt_utils.get("subnet6") ipv6_managers[m.get("network")] = { "ip": m.get("network"), "subnet": m.get("netmask")} vlans = dict() dhcp_snooping_vlans = list() dhcpv6_snooping_vlans = list() arp_protect = { "vlans": list() } for vlan in re2o_config.get("vlans"): vlan_id = vlan["vlan_id"] vlans[vlan_id] = vlan range_tagged = list() range_untagged = list() # on récupère les ports tag et untagged for port in re2o_config.get("ports"): port_profile = port["get_port_profile"] for v in port_profile["vlan_tagged"]: print(v) if v["vlan_id"] == vlan_id: range_tagged.append(port["port"]) # i n'y a qu'un seul vlan untagged v = port_profile["vlan_untagged"] if v is not None and v["vlan_id"] == vlan_id: range_untagged.append(port["port"]) vlans[vlan_id]["tagged"] = syntax_from_range(range_tagged) vlans[vlan_id]["untagged"] = syntax_from_range(range_untagged) # on rajoute les ips sur les vlans où il y en a for address, iface in re2o_config.get("interfaces_subnet", dict()).items(): # ouais y'a une autre liste là, don't ask for i in iface: if i["vlan_id"] == vlan_id: if vlans[vlan_id].get("ip") is None: vlans[vlan_id]["ip"] = dict() vlans[vlan_id]["ip"]["addr"] = address vlans[vlan_id]["ip"]["subnet"] = i["netmask"] for address, iface in re2o_config.get("interfaces6_subnet", dict()).items(): if iface["vlan_id"] == vlan_id: if vlans[vlan_id].get("ip") is None: vlans[vlan_id]["ip"] = dict() vlans[vlan_id]["ip"]["addr6"] = address vlans[vlan_id]["ip"]["subnet6"] = iface["netmask_cidr"] # on ajoute les vlans qui ont besoin du dhcp snooping if vlan["dhcp_snooping"]: dhcp_snooping_vlans.append(vlan_id) if vlan["dhcpv6_snooping"]: dhcpv6_snooping_vlans.append(vlan_id) if vlan["arp_protect"]: arp_protect["vlans"].append(vlan_id) vlans[vlan_id]["ipv6_mld"] = vlan["mld"] # on récupère les informations intéressantes sur les ports mac_based_ports = list() ra_guard_ports = list() interfaces = list() loop_protect = { "ports": list()} for port in re2o_config.get("ports"): port_profile = port["get_port_profile"] if port_profile["ra_guard"]: ra_guard_ports.append(port["port"]) if port_profile["loop_protect"]: loop_protect["ports"].append(port["port"]) iface = { "name": port["pretty_name"], "number": port["port"], "dhcp_trust": not port_profile["dhcp_snooping"], "dhcpv6_trust": not port_profile["dhcpv6_snooping"], "flowcontrol": port_profile["flow_control"], "arp_trust": not port_profile["arp_protect"], } if port_profile["radius_type"] == "MAC-radius": mac_based_ports.append(port["port"]) iface["mac_based"] = True iface["addr_limit"] = port_profile["mac_limit"] iface["logoff"] = master_config.get("radius_logoff") interfaces.append(iface) loop_protect["ports"] = syntax_from_range(loop_protect["ports"]) arp_protect["vlans"] = syntax_from_range(arp_protect["vlans"], vlan_syntax=True) interfaces.sort(key=lambda x: x["number"]) radius_key = re2o_config.get("get_radius_key_value") radius_servers = [ {"ip": i, "secret": radius_key } for i in mgmt_utils["radius_servers"]["ipv4"] + mgmt_utils["radius_servers"]["ipv6"]] config_dict = { "header": header, "location": re2o_config.get("switchbay").get("name"), "hostname": re2o_config.get("short_name"), "dhcp_servers": mgmt_utils.get("dhcp_servers").get("ipv4"), "dhcpv6_servers": mgmt_utils.get("dhcp_servers").get("ipv6"), "ipv4_managers": ipv4_managers, "ipv6_managers": ipv6_managers, "vlans": vlans, "dhcp_snooping_vlans": syntax_from_range(dhcp_snooping_vlans, vlan_syntax=True), "dhcpv6_snooping_vlans": syntax_from_range(dhcpv6_snooping_vlans, vlan_syntax=True), "logging": mgmt_utils["log_servers"]["ipv4"] + mgmt_utils["log_servers"]["ipv6"], "sntp": mgmt_utils["ntp_servers"]["ipv4"] + mgmt_utils["ntp_servers"]["ipv6"], "dns": mgmt_utils["dns_recursive_servers"]["ipv4"] + mgmt_utils["dns_recursive_servers"]["ipv6"], "radius_servers": radius_servers, "snmp_user": master_config.get("snmp_user"), "unauth_redirect": master_config.get("unauth_redirect"), "mac_based_ports": syntax_from_range(mac_based_ports), "ra_guard_ports": syntax_from_range(ra_guard_ports), "loop_protect": loop_protect, "arp_protect": arp_protect, "interfaces": interfaces, "FUCK": ['interfaces_subnet', 'ports', 'ipv6', 'ipv4', 'get_radius_key_value', 'interfaces6_subnet', 'list_modules'] } pprint(re2o_config) # pprint(re2o_config.get("interfaces_subnet")) # pprint(re2o_config.get("list_modules")) # raise RuntimeError() return conf_from_dict(config_dict) def connect_as_self(base_url, username=None): """Get a re2o token for the current unix user """ if username is None: username = getpass.getuser() r = requests.post( base_url + "token-auth", data={ "username": username, "password": getpass.getpass("Login to {} as {} with password :".format(base_url, username)) } ) if r.status_code != 200: logger.critical("Wrong login/password") exit(1) token = r.json().get("token") return token def get_switch_from_results(results, switch_name): for s in results: if s.get("short_name") == switch_name: return s return None def get_switch_from_re2o(re2o_instance, switch_name, re2o_user): base_url = "{}/api/".format(re2o_instance) token = connect_as_self(base_url, re2o_user) headers = {"Authorization": "Token " + token} # On récupère la config du bon switch r = requests.get(base_url + "switchs/ports-config", headers=headers) sw_config = get_switch_from_results(r.json()["results"], switch_name) while r.json().get("next") and s is None: r = requests.get(r.json().get("next"), headers=headers) sw_config = get_switch_from_results(r.json()["results"], switch_name) # on récupère les infos globales pour dhcp, managers etc. r = requests.get(base_url + "preferences/optionaltopologie", headers=headers) sw_config.update(r.json()) # on récupère la liste des vlans r = requests.get(base_url + "machines/vlan", headers=headers) pprint(r.json().get("results")) sw_config.update({"vlans": r.json().get("results")}) return sw_config if __name__ == "__main__": format_string = "%(asctime)s - %(levelname)s - %(message)s" stdout_handler = logging.StreamHandler() stdout_formatter = colorlog.ColoredFormatter("%(log_color)s{}".format(format_string)) stdout_handler.setFormatter(stdout_formatter) logger.addHandler(stdout_handler) logger.setLevel(logging.DEBUG) parser = argparse.ArgumentParser(description="Script de déploiement de la configuration des switchs") parser.add_argument("-d", "--dry-run", action="store_true", help="Génère la nouvelle configuration et affiche le diff \ sans tenter de l'appliquer") parser.add_argument("-w", "--whole", action="store_true", help="Affiche la configuration en entier au lieu du diff") parser.add_argument("switch_name", type=str, help="Génère le template de ce switch") parser.add_argument("-H", "--host", type=str, required=False, help="Host sur lequel de déployer la configuration au lieu de l'adresse dans le template") parser.add_argument("-r", "--re2o", type=str, required=False, help="Si renseigné, la configuration sera récupérée depuis l'instance de re2o indiquée au lieu d'utiliser les fichiers yaml") parser.add_argument("--re2o-user", type=str, required=False, help="Permet de choisir l'user pour se connecter à l'api re2o, par défaut on prend l'user unix courant") parser.add_argument("-4", "--force-ipv4", action="store_true", help="Force le provisionning en ipv4") args = parser.parse_args() if args.re2o: logger.debug("Loading master config") master_config = yaml.load(open("configs/master.yml", "r"), yaml.Loader) logger.debug("Loading config from re2o") re2o_config = get_switch_from_re2o(args.re2o, args.switch_name, args.re2o_user) else: logger.debug("Loading master config") master_config = yaml.load(open("configs/master.yml", "r"), yaml.Loader) logger.debug("Loading config for {}".format(args.switch_name)) switch_config = yaml.load(open("configs/switches/{}.yml".format(args.switch_name), "r"), yaml.Loader) if args.host: switch_address = args.host elif args.re2o: if args.force_ipv4: switch_address = re2o_config.get("ipv4") else: switch_address = re2o_config.get("ipv6") or re2o_config.get("ipv4") else: if args.force_ipv4: switch_address = switch_config.get("ipv4-addr") else: switch_address = switch_config.get("ipv6-addr") or switch_config.get("ipv4-addr") if switch_address is None: switch_address = "{}.switches.crans.org".format(args.switch_name) #TODO: crans logger.info("Connecting to {} with address {}".format(args.switch_name, switch_address)) session = connect_to_switch(switch_address, user="root", key=master_config.get("ssh_private_key")) #TODO: spécifier chemin clef old_config = sftp_read_file(session, "cfg/running-config").decode("utf-8") header = get_header(old_config) # génération de la conf logging.info("Generating configuration for {}".format(args.switch_name)) if args.re2o: configuration = gen_conf_re2o(re2o_config, header) else: configuration = gen_conf(master_config, switch_config, header) # génération du diff for line in difflib.unified_diff(old_config.split("\n"), configuration.split("\n"), fromfile='origin', tofile='new', lineterm=""): if line.startswith("-"): termcolor.cprint(line, "red") elif line.startswith("+"): termcolor.cprint(line, "green") elif line.startswith("@"): termcolor.cprint(line, "yellow") else: print(line) if args.dry_run or input("Voulez-vous déployer la configuration sur le switch ? y/[n]").lower() not in ["o","y"]: logger.info("Aborting deployement") exit(0) with open("/tmp/conf_tmp", "w") as conf_tmp: conf_tmp.write(configuration) del session logging.info("Uploading configuration for {}".format(args.switch_name)) session = connect_to_switch(switch_address, user="crans", key=master_config.get("ssh_private_key")) sftp_write_file(session, "/tmp/conf_tmp", "cfg/startup-config") logging.info("Deployement done for {}".format(args.switch_name)) # on retire ces deux lignes qui sont hardcodées dans les templates crans # c'est deux adresses de multicast au pif, wtf ? # https://gitlab.crans.org/nounous/scripts/-/commit/af2d158ff1a99dee2f032a81bf14de4144d2b82f #-filter multicast 01005e-0000fb drop 1-52 #-filter multicast 333300-0000fb drop 1-52