def vrf_assignment():
render_vrf = render_template()
to_add_vrf = render_vrf.assign_vrf()
for vrf in to_add_vrf:
vrf_conv = json.loads(vrf)
try:
vrf_dup = nautobot.ipam.ip_addresses.get(
device=vrf_conv["dns_name"], interface=vrf_conv["description"])
except:
pass
print(vrf_dup)
if vrf_dup == None:
print("Cannot assign vrf to " + vrf_conv["dns_name"] + " with interface " + \
vrf_conv["description"])
elif vrf_dup.vrf == None and vrf_dup != None:
if vrf_conv["address"] in str(vrf_dup):
address_ = str(vrf_dup)
try:
my_vrf = nautobot.ipam.ip_addresses.get(address=address_)
vrf_conv["address"] = address_
vrf_conv["dns_name"] = " "
vrf_conv["description"] = " "
print(vrf_conv)
add_vrf = my_vrf.update(vrf_conv)
except pynautobot.RequestError as e:
print(e.error)
pass
else:
print("Duplicated vrf " + vrf_conv["dns_name"])
print("Done")
def connect_cables():
my_conn = nautobot.dcim.cables
render_conn = render_template()
to_add_conn = render_conn.add_connection()
for conn in to_add_conn:
conn_conv = json.loads(conn)
source = nautobot.dcim.interfaces.get(
name=conn_conv["termination_a_id"][0],
device=conn_conv["termination_a_id"][1])
target = nautobot.dcim.interfaces.get(
name=conn_conv["termination_b_id"][0],
device=conn_conv["termination_b_id"][1])
if source != None:
conn_conv["termination_a_id"] = source.id
if target != None:
conn_conv["termination_b_id"] = target.id
try:
print(conn_conv)
add_conn = my_conn.create(conn_conv)
print("Done with " + str(source) + " " + str(target))
except pynautobot.RequestError as e:
error_log.write("{0} {1}\n{2}\n".format(source, target,
str(e.error)))
print(source, target)
print(e.error)
pass
def region():
my_region = nautobot.dcim.regions
render_region = render_template()
to_add_region = render_region.region()
for regions in to_add_region:
add_region = my_region.create(regions)
print("Done")
def ipadd_be():
my_ipadd = nautobot.ipam.ip_addresses
render_ipadd = render_template()
to_add_ipadd = render_ipadd.ipadd_be()
for ipadd in to_add_ipadd:
ipadd_conv = json.loads(ipadd)
#print(ipadd_conv)
bundle = nautobot.dcim.interfaces.get(
name=ipadd_conv["assigned_object"]["name"],
device=ipadd_conv["assigned_object"]["device"]["name"])
print(bundle)
try:
dup_ip = my_ipadd.get(assigned_object_id=bundle.id,
address=ipadd_conv["address"])
except:
print("No address or no interface defined!")
if bundle != None and dup_ip == None:
print(bundle.id)
ipadd_conv['assigned_object']['id'] = bundle.id
ipadd_conv['assigned_object_id'] = bundle.id
print(ipadd_conv)
# try:
add_ipadd = my_ipadd.create(ipadd_conv)
# except pynautobot.RequestError as e:
# print(e.error)
# pass
elif bundle == None:
print("No defined interface bundle")
elif dup_ip != None:
print("Duplicate IP " + ipadd_conv['address'])
print("Done")
def roles():
my_roles = nautobot.dcim.device_roles
render_roles = render_template()
to_add_roles = render_roles.roles()
for roles in to_add_roles:
print(roles)
roles_conv = json.loads(roles)
add_roles = my_roles.create(json.loads(roles))
print("Done")
def update_custom():
my_custom = nautobot.dcim.devices.get(
"33e89bbe-6da2-411e-9fca-7792a66b22bf")
render_custom = render_template()
to_add_custom = render_custom.custom_field()
for fields in to_add_custom:
try:
print(fields)
add_custom = my_custom.update(json.loads(fields))
except:
print('Cannot upload ' + fields + '.')
print("Done")
def loopback():
my_interface = nautobot.dcim.interfaces
render_interfaces = render_template()
to_add_interfaces = render_interfaces.loop_interfaces()
for interfaces in to_add_interfaces:
try:
print(interfaces)
interfaces_conv = json.loads(interfaces)
add_interfaces = my_interface.create(interfaces_conv)
except:
print('Cannot upload ' + interfaces)
print("Done")
def devices():
my_devices = nautobot.dcim.devices
render_devices = render_template()
to_add_devices = render_devices.devices()
for devices in to_add_devices:
try:
print(devices)
devices_conv = json.loads(devices)
add_devices = my_devices.create(devices_conv)
except pynautobot.RequestError as e:
print(e.error)
pass
print("Done")
def bundle_interface():
my_be = nautobot.dcim.interfaces
render_be = render_template()
to_add_be = render_be.be_int()
for be in to_add_be:
try:
print(be)
be_conv = json.loads(be)
add_be = my_be.create(be_conv)
except pynautobot.RequestError as e:
print(e.error)
pass
print("Done")
def physical_interface():
my_phy = nautobot.dcim.interfaces
render_phy = render_template()
to_add_phy = render_phy.phy_int()
for phy in to_add_phy:
try:
print(phy)
phy_conv = json.loads(phy)
add_phy = my_phy.create(phy_conv)
except pynautobot.RequestError as e:
print(e.error)
pass
print("Done")
def sites():
my_sites = nautobot.dcim.sites
render_sites = render_template()
to_add_sites = render_sites.sites()
for sites in to_add_sites:
try:
print(sites)
sites_conv = json.loads(sites)
add_sites = my_sites.create(sites_conv)
except pynautobot.RequestError as e:
print(e.error)
pass
print("Done")
def update_device():
my_devices = nautobot.dcim.devices.get(
"33e89bbe-6da2-411e-9fca-7792a66b22bf")
render_devices = render_template()
to_add_devices = render_devices.patch_devices()
for devices in to_add_devices:
try:
print(devices)
add_devices = my_devices.update(json.loads(devices))
except:
print('Cannot upload ' + devices +
'. Check for duplicates or hostname in wrong format!')
print("Done")
def assign_primary():
my_primary = nautobot.dcim.devices.get(
"33e89bbe-6da2-411e-9fca-7792a66b22bf")
render_primary = render_template()
to_add_primary = render_primary.patch_devices()
for pri in to_add_primary:
try:
print(pri)
pri_conv = json.loads(pri)
add_primary = my_primary.update(pri_conv)
except pynautobot.RequestError as e:
print(e.error)
pass
print("Done")
def ipadd_loop():
my_ipadd = nautobot.ipam.ip_addresses
render_ipadd = render_template()
to_add_ipadd = render_ipadd.ipadd_loopback()
for ipadd in to_add_ipadd:
try:
print(ipadd)
ipadd_conv = json.loads(ipadd)
add_ipadd = my_ipadd.create(ipadd_conv)
except pynautobot.RequestError as e:
print(e.error)
pass
print("Done")
def interface_shut():
my_phy = nautobot.dcim.interfaces
render_phy = render_template()
to_add_phy = render_phy.shut_interfaces()
for phy in to_add_phy:
try:
print(phy)
phy_conv = json.loads(phy)
#my_phy = nautobot.dcim.interfaces.get(device=phy_conv["device"]["name"],name=phy_conv["name"])
add_phy = my_phy.create(phy_conv)
#add_phy = my_phy.update(phy_conv)
except pynautobot.RequestError as e:
print(e.error)
pass
print("Done")
def inventory():
my_inventory = nautobot.dcim.inventory_items
render_devices = render_template()
to_add_inventory = render_devices.inventory()
for inventory in to_add_inventory:
inventory_conv = json.loads(inventory)
device = nautobot.dcim.devices.get(
name=inventory_conv["device"]["name"])
if device != None:
inventory_conv["device"]["id"] = device.id
print(inventory_conv)
try:
add_inventory = my_inventory.create(inventory_conv)
except pynautobot.RequestError as e:
print(e.error)
pass
print("Done")
def vrf():
my_vrf = nautobot.ipam.vrfs
render_vrf = render_template()
to_add_vrf = render_vrf.vrf()
for vrf in to_add_vrf:
vrf_conv = json.loads(vrf)
dup_vrf = nautobot.ipam.vrfs.get(name=vrf_conv["name"])
if dup_vrf == None:
try:
print(vrf)
add_vrf = my_vrf.create(vrf_conv)
except pynautobot.RequestError as e:
print(e.error)
pass
else:
print("Duplicated vrf " + str(dup_vrf))
print("Done")
def vlan():
my_vlan = nautobot.ipam.vlans
render_vlan = render_template()
to_add_vlan = render_vlan.vlan()
for vlan in to_add_vlan:
vlan_conv = json.loads(vlan)
dup_vlan = nautobot.ipam.vlans.get(name=vlan_conv["name"])
if dup_vlan == None:
try:
print(vlan)
add_vlan = my_vlan.create(vlan_conv)
except pynautobot.RequestError as e:
print(e.error)
pass
else:
print("Duplicated vlan " + str(dup_vlan))
print("Done")
def rt():
my_rt = nautobot.ipam.route_targets
render_rt = render_template()
to_add_rt = render_rt.rt()
for rt in to_add_rt:
rt_conv = json.loads(rt)
try:
dup_rt = nautobot.ipam.route_targets.get(name=rt_conv["name"])
except:
continue
if dup_rt == None:
try:
print(rt)
add_rt = my_rt.create(rt_conv)
except pynautobot.RequestError as e:
print(e.error)
pass
else:
print("Duplicated RT " + str(dup_rt))
print("Done")
def assign_rt():
render_rt = render_template()
to_add_rt = render_rt.assign_rt()
for rt in to_add_rt:
print(rt)
rt_conv = json.loads(rt)
try:
dup_rt = nautobot.ipam.vrfs.get(import_targets=rt_conv["import_targets"],export_targets=rt_conv\
["export_targets"])
except:
dup_rt = None
pass
if dup_rt == None:
my_rt = nautobot.ipam.vrfs.get(name=rt_conv["name"])
if my_rt != None:
rt_ex_list = []
rt_imp_list = []
for rt_ex in rt_conv["export_targets"]:
print(rt_ex)
rt_export = nautobot.ipam.route_targets.get(name=rt_ex)
rt_ex_id = rt_export.id
rt_ex_list.append(rt_ex_id)
for rt_imp in rt_conv["import_targets"]:
print(rt_imp)
rt_import = nautobot.ipam.route_targets.get(name=rt_imp)
rt_imp_id = rt_import.id
rt_imp_list.append(rt_imp_id)
rt_conv["export_targets"] = rt_ex_list
rt_conv["import_targets"] = rt_imp_list
print(rt_conv)
# try:
add_rt = my_rt.update(rt_conv)
print("Done for " + rt_conv["name"])
# except pynautobot.RequestError as e:
# print(e.error)
# pass
else:
continue
else:
print("Duplicated RT " + str(dup_rt))
print("Done")
def assign_vlan():
render_vlan = render_template()
to_add_vlan = render_vlan.assign_vlan()
for vlan in to_add_vlan:
print(vlan)
vlan_conv = json.loads(vlan)
try:
vlan_dup = nautobot.dcim.interfaces.get(device=vlan_conv["device"]["name"], interface=vlan_conv["name"],\
vlan=vlan_conv["untagged_vlan"])
except:
pass
print(vlan_dup)
# if vlan_dup == None:
# print("Cannot assign vlan to " + vlan_conv["device"]["name"] + " with interface " + \
# vrf_conv["name"])
if vlan_dup == None:
my_vlan = nautobot.ipam.vlans.get(name=vlan_conv["untagged_vlan"])
my_vlan_int = nautobot.dcim.interfaces.get(name=vlan_conv["name"],\
device=vlan_conv["device"]["name"])
vlan_conv["untagged_vlan"] = my_vlan.id
print(vlan_conv)
if my_vlan_int != None:
try:
add_vlan = my_vlan_int.update(vlan_conv)
except pynautobot.RequestError as e:
error_log.write("{0} {1}\n{2}\n".format(
vlan_conv["name"], vlan_conv["device"]["name"],
str(e.error)))
print(e.error)
pass
else:
error_log.write("Hostname " + vlan_conv["device"]["name"] + " and/or interface " + \
vlan_conv["name"] + " is not yet defined.\n")
print("Hostname " + vlan_conv["device"]["name"] + " and/or interface " + \
vlan_conv["name"] + " is not yet defined.")
else:
error_log.write("Duplicated vlan of " + vlan_conv["device"]["name"] + " " + vlan_conv["name"] + " " + \
vlan_conv["untagged_vlan"] + "\n")
print("Duplicated vlan of " + vlan_conv["device"]["name"] + " " +
vlan_conv["name"] + " " + vlan_conv["untagged_vlan"])
print("Done")
def main(config):
### MODULE IMPORTS
import os, string
import xml.etree.ElementTree as ET
from os import path
from string import Template
from collections import ChainMap
from modules.helpers import read_json
from modules.helpers import log_error
from modules.helpers import log_ok
from modules.helpers import go_to_folder
from modules.helpers import create_file
from modules.helpers import read_template
from modules.helpers import obj_forbidden
from modules.helpers import write_line
from modules.helpers import get_stored_value
from modules.parse_values import main as parse_values
from modules.parse_classes import main as parse_classes
from modules.do_operation import do_operation
from modules.render_template import render_template
log_ok("Initializing...")
### PATH VALUES
MODULE_PATH = os.path.join(os.path.dirname(__file__))
HOME_DIR = os.getcwd()
### PARSE JSON CONFIG FILE
try:
config = read_json(config)
except Exception as e:
return log_error("Invalid config file.")
finally:
log_ok("Valid config file.")
### STORE ALL GLOBAL VALUES
try:
classes = read_json("classes.json")
stored_values = parse_values(classes["values"])
stored_classes = parse_classes(classes["classes"])
except Exception as e:
return log_error(f"Invalid classes file or error: {e}")
### SPACING VALUES
TEMPLATE_LINE = 5
TAB_SPACE = 3
NL = "\n"
### ROOT CONFIG VARIABLES
try:
MODS_DIR = config["target_folder"]
OUTPUT_DIR = config["output_folder"]
CONFIG_MODS = config["main"]
except Exception as e:
return log_error((f"Property: {str(e)} missing from main config."))
GAME_MODS_DIR = (MODS_DIR + "/")
try:
if not os.path.exists(OUTPUT_DIR):
raise
except Exception:
return log_error("Output directory does not exist.")
finally:
log_ok("Valid output directory.")
### MOD CONFIG VARIABLES
for mod in CONFIG_MODS:
try:
mod_folder = mod["folder"]
mod_defs = mod["defs"]
except Exception as e:
return log_error((f"Property: {str(e)} missing from mod config."))
try:
folder_name = (mod["label"] if ("label" in mod) else mod_folder)
current_def_path = (GAME_MODS_DIR + mod_folder + "/Defs/")
except Exception as e:
return log_error(e)
### DEF CONFIG VARIABLES
for mod_def in mod_defs:
print("--------------")
try:
def_folder = mod_def["folder"]
def_files = mod_def["files"]
except Exception as e:
return log_error(
(f"Property: {str(e)} missing from def config."))
try:
def_path = ("/" +
mod_def["path"]) if ("path" in mod_def) else "Defs"
def_defType = mod_def["defType"] if (
"defType" in mod_def) else "ThingDef"
mod_def_path = (current_def_path + def_folder + "/")
def_file_exported = {}
except Exception as e:
return log_error(e)
### CREATE BASE FOLDER FOR MOD
go_to_folder(OUTPUT_DIR, folder_name, HOME_DIR)
log_ok(f"Mod folder {folder_name} created.")
### FILE CONFIG VARIABLES
for def_file in def_files:
try:
def_file_defName = def_file["defName"]
def_defFilename = def_file["filename"] if (
"filename" in def_file) else None
def_file_properties = def_file["properties"]
except Exception as e:
return log_error(
(f"Property: {str(e)} missing from file config."))
### PARSE CLASS PROPERTIES
try:
def_file_Class = def_file["Classes"] if (
"Classes" in def_file) else None
if not (def_file_Class is None):
cache_properties = []
for c_class in def_file_Class:
if (c_class in stored_classes):
def_file = (dict(
ChainMap(stored_classes[c_class],
def_file)))
matching_class = stored_classes[c_class]
if ("properties" in matching_class):
for vp in matching_class["properties"]:
cache_properties.append(vp)
for vp in def_file_properties:
cache_properties.append(vp)
def_file_properties = cache_properties
def_file.pop("Classes", None)
except Exception as e:
return log_error(e)
print("-----------------")
### PARSE XML FILE
try:
xml_file = (mod_def_path + def_file_defName + ".xml")
if not os.path.isfile(xml_file):
raise
except Exception as e:
return log_error(f"File {xml_file} does not exist!")
try:
tree = ET.parse(xml_file)
root = tree.getroot()
except Exception as e:
return log_error(f"Failed to parse XML file. ({e}).")
log_ok(f"Read {def_file_defName}.xml.", 2)
def_file_exported[def_file_defName] = []
exported_properties = {}
### CREATE DEF SUB-FOLDER
go_to_folder(os.path.join(OUTPUT_DIR, folder_name), def_folder,
HOME_DIR)
### ITERATE THROUGH OBJECTS
for object_def in root.iter(def_defType):
try:
obj_defName = object_def.find("defName").text if (
object_def.find("defName")
is not None) else object_def.get("Name")
except Exception as e:
return log_error(e)
### CHECK IF OBJECT IS INCLUDED/EXCLUDED
if obj_forbidden(def_file, obj_defName):
continue
### OPTIONAL LABEL/DESC VARIABLES
try:
obj_label = object_def.find("label").text if (
object_def.find("label") is not None) else ""
obj_defType = def_file["defType"] if (
"defType" in def_file) else def_defType
exported_properties[obj_defName] = {
"label": obj_label,
"values": []
}
except Exception as e:
return log_error(e)
### LOOP THROUGH OBJECT PROPERTIES
for def_prop in def_file_properties:
try:
def_prop_tree = def_prop["tree"]
def_prop_property = def_prop["property"]
def_prop_procedure = def_prop["procedure"] if (
"procedure" in def_prop) else "Replace"
except Exception as e:
return log_error((
f"Property: {str(e)} missing from property config."
))
try:
prop_path = "/".join(def_prop_tree)
except Exception as e:
return log_error(e)
### PROPERTY FILTER FOR INCLUDED/EXCLUDED OBJECTS
for target_prop in object_def.findall(prop_path):
if obj_forbidden(def_prop, obj_defName):
continue
ftp = 0
final_prop_path = ""
if (def_prop_procedure == "Replace"):
final_prop_path = (
f"{prop_path}/{def_prop_property}")
for final_prop in target_prop.iter(
def_prop_property):
fpt = final_prop.text
### PERFORM ARITHMETIC OPERATION OR ASSIGN VALUE
try:
if ("operation" in def_prop):
normalized_values = get_stored_value(
def_prop["operation"],
stored_values)
fpt = float(
fpt) if '.' in fpt else int(
fpt)
fpt = do_operation(
fpt, normalized_values)
fpt = round(
fpt, normalized_values[3] if
(len(normalized_values)
== 4) else 2)
elif ("value" in def_prop):
fpt = get_stored_value(
def_prop["value"],
stored_values)[0]
else:
raise
except Exception as e:
return log_error(
f"Property '{obj_defName}' has no valid value or operation: {e}."
)
if (def_prop_procedure == "Add"):
final_prop_path = (f"{prop_path}")
for proc_key, proc_attr in def_prop_property.items(
):
def_prop_property[
proc_key] = get_stored_value(
proc_attr, stored_values)[0]
### APPEND NEW DICTIONARY INTO LIST
this_export = {
"defType":
obj_defType,
"defPath":
def_path,
"defName":
obj_defName,
"propPath":
final_prop_path,
"mainProp":
def_prop_property,
"finalValue":
fpt,
"defProcedure":
def_prop_procedure,
"finalFilename":
def_defFilename,
"taskDesc":
def_prop["desc"] if
("desc" in def_prop) else None
}
exported_properties[obj_defName]["values"].append(
this_export)
log_ok("Properties processed.", 3)
### APPEND DEF LIST INTO MOD PROPERTIES
def_file_exported[def_file_defName].append(exported_properties)
### LOOP THROUGH MOD PROPERTIES
log_ok(f"Creating patch files...", 1)
for attr, sub_mod_def in def_file_exported.items():
log_ok(f"/{def_folder}:", 2)
### CREATE OUTPUT FILE AND READ MAIN TEMPLATE
output_filename = attr
for def_key in def_files:
if (("filename" in def_key)
and (def_key["defName"] == attr)):
output_filename = def_key["filename"]
try:
output_file = create_file(
os.path.join(OUTPUT_DIR, folder_name, def_folder),
(output_filename + ".xml"))
tpl_template = read_template(HOME_DIR, "main")
sub_def_file = {}
except Exception as e:
return log_error(e)
### LOOP THROUGH TEMPLATE LINES UNTIL MIDDLE SECTION
for line_count, main_template_line in enumerate(tpl_template):
if (line_count == TEMPLATE_LINE):
### MOD HEADER COMMENT
try:
mod_header_dict = {
"label":
("CONTENT: " + (mod["label"] if "label" in mod
else mod_folder)),
"desc":
mod["desc"] if ("desc" in mod) else "",
}
for line in read_template(HOME_DIR, "header_long"):
output_file.write(
write_line(
render_template(
"header_long", Template(line),
mod_header_dict), 1))
except Exception as e:
return log_error(e)
### DEF HEADER COMMENT
try:
sub_def_file = {}
for s in def_files:
if (s["defName"] == attr): sub_def_file = s
if (len(sub_def_file) > 0):
def_header_dict = {
"label":
("PATCH: " +
((sub_def_file["label"])
if "label" in sub_def_file else "")),
"desc":
sub_def_file["desc"]
if "desc" in sub_def_file else "",
}
if ("label" in sub_def_file):
for line in read_template(
HOME_DIR, "header_mid"):
output_file.write(
write_line(
render_template(
"header_long",
Template(line),
def_header_dict),
(TAB_SPACE - 1)))
except Exception as e:
return log_error(e)
### LOOP THROUGH DEF OBJECTS
for prop in sub_mod_def:
for i, sp_def_file in prop.items():
### OBJECT LABEL COMMENT
if (len(sp_def_file["values"]) > 0):
try:
labelHeader = sp_def_file["label"] if (
"label" in sp_def_file) else i
for line in read_template(
HOME_DIR, "header"):
output_file.write(
write_line(
render_template(
"header",
Template(line),
{"label": labelHeader
}), TAB_SPACE))
except Exception as e:
return log_error(e)
for exp_values in sp_def_file["values"]:
### TASK DESCRIPTION COMMMENT
if (exp_values["taskDesc"]
is not None):
try:
for line in read_template(
HOME_DIR, "header"):
output_file.write(
write_line(
render_template(
"header",
Template(line),
{
"label":
("CHANGE: "
+
exp_values[
"taskDesc"]
)
}), TAB_SPACE,
0))
output_file.write(NL)
except Exception as e:
return log_error(e)
### WRITE REPLACEMENT XPATH OPERATION
valuesList = ""
mainProp = exp_values["mainProp"]
finalValue = exp_values["finalValue"]
if (exp_values["defProcedure"] ==
"Replace"):
valuesList = (
valuesList + get_proc_line(
mainProp, finalValue))
if (exp_values["defProcedure"] == "Add"
):
for exp_key, exp_attr in mainProp.items(
):
valuesList = (
valuesList + get_proc_line(
exp_key, exp_attr))
exp_values["valuesList"] = valuesList
try:
for line in read_template(
HOME_DIR, "procedure"):
output_file.write(
write_line(
render_template(
"main",
Template(line),
exp_values),
TAB_SPACE, 0))
except Exception as e:
return log_error(e)
output_file.write(NL * 2)
else:
output_file.write(main_template_line)
log_ok(f"Created {attr}.", 3)
### CLOSES FILES
output_file.close()
tpl_template.close()
print()
log_ok("All tasks executed successfully!")
True
### 👍😎
