def list(self, org_id): success = False networks = None try: success, networks = meraki.getnetworklist(config.api_key, org_id) if success: log.logger.debug("success") log.logger.debug(Json.make_pretty(networks)) else: log.logger.error("failed.") log.logger.error("networks: {}".format(networks)) gv.fake_assert() except (meraki.EmailFormatError, meraki.OrgPermissionError, meraki.ListError) as err: log.logger.error("orgid: {} Meraki error: {}".format( org_id, err.default)) log.runlogs_logger.error("orgid: {} Meraki error: {}".format( org_id, err.default)) exit(-1) except Exception as err: log.logger.error("orgid: {}".format(org_id)) log.runlogs_logger.error("orgid: {}".format(org_id)) gv.fake_assert() return success, networks
def claim(self, serial, licensekey=None, licensemode=None, orderid=None): success = False str = None try: success, self.claim = meraki.claim(config.api_key, settings["org-id"], serial, licensekey, licensemode, orderid) if not success: runlogs_logger.error("orgid: {} serial:{} claim:{}".format( settings["org-id"], serial, self.claim)) logger.error("orgid: {} serial:{} claim:{}".format( settings["org-id"], serial, self.claim)) return False #json.writer("claim_{}".format(serial), self.claim) except (meraki.EmailFormatError, meraki.OrgPermissionError, meraki.ListError) as err: logger.error("orgid: {} Meraki error: {}".format( settings["org-id"], err.default)) runlogs_logger.error("orgid: {} Meraki error: {}".format( settings["org-id"], err.default)) exit(-1) except Exception as err: logger.error("serial:{}".format(serial)) runlogs_logger.error("serial:{}".format(serial)) gv.fake_assert() return success
def set_each(self, netid, fw_rules, store_number): success = False str = None try: fwrules = json.reader("l3fwrules_deploy_{}".format(store_number)) singleRule = [] for rule in fwrules: singleRule.append(rule) success, str = meraki.updatemxl3fwrules( config.api_key, netid, singleRule) log.logger.debug(rule["comment"]) if not success: log.logger.error("failed rule comment:{} {}".format( rule["comment"], str)) log.runlogs_logger.error("failed rule comment:{} {}".format( rule["comment"], str)) gv.fake_assert() except (meraki.EmailFormatError, meraki.OrgPermissionError, meraki.ListError) as err: log.logger.error("Meraki error: {}".format(err.default)) log.runlogs_logger.error("Meraki error: {}".format(err.default)) exit(-1) except Exception as err: log.logger.error("exception failure netid:{} {}".format( netid, str)) log.runlogs_logger.error("exception failure netid:{}".format(str)) gv.fake_assert() return success, str
def perform_bulk_get_vpn_firewall(agent, org_list_fname, fn_get): l.runlogs_logger.info("downloading {}".format(agent)) org_list = Json.reader(org_list_fname, "templates") Csv.transform_to_csv(org_list_fname, None, path="templates") org_name = org_list[0].get("org_name", None) auto_globals.load_org(agent, org_name) if org_name is None: str = "org {} not found".format(org_name) l.logger.error(str) l.runlogs_logger.error(str) gv.fake_assert() try: str = "downloading vpns2srules for org: {}".format(org_name) l.logger.info(str) l.runlogs_logger.info(str) fn_get(agent) except: str = "failed obtaining s2svpnrules for org: {}".format(org_name) l.logger.error(str) l.runlogs_logger.info(str) gv.fake_assert() str = 'downloaded s2svpnrules for org : "{}"'.format(org_name) l.logger.info(str) l.runlogs_logger.info(str)
def data_to_csv(self, json_data, fname_csv, header=None): if type(json_data) == list: fieldNames = [k for k in json_data[0].keys()] else: fieldNames = [k for k in json_data.keys()] # Turn boolean field names into strings self.fix_bool_to_lower(json_data) if header is not None: headerOkay=True for column in header: if column not in fieldNames: headerOkay=False l.logger.error("header column: {} not found".format(column)) gv.EOM() gv.fake_assert() if headerOkay is False: return # This will make it use the order provided fieldNames=header try: import os if os.name == 'nt' : with open(fname_csv, 'w', newline='') as csvfile: self.write_lines(csvfile, fieldNames, json_data) else: with open(fname_csv, 'w') as csvfile: self.write_lines(csvfile, fieldNames, json_data) except Exception as err: l.logger.error("fname:{}".format(fname_csv)) l.runlogs_logger.error("fname:{}".format(fname_csv)) gv.fake_assert()
def add(self, netid, name, subnet, ip): success = False str = None try: success, str = meraki.addstaticroute(config.api_key, netid, name, subnet, ip) log.logger.info("success {}".format(str)) if not success: log.logger.error("{}".format(str)) log.runlogs_logger.error("{}".format(str)) gv.fake_assert() except (meraki.EmailFormatError, meraki.OrgPermissionError, meraki.ListError) as err: log.logger.error("Meraki error: {}".format(err.default)) log.runlogs_logger.error("Meraki error: {}".format(err.default)) exit(-1) except Exception as err: log.logger.error("exception failure {} for netid:{} \n{}".format( netid, err, str)) log.runlogs_logger.error("exception failure {} \n{}".format( err, str)) gv.fake_assert() return success, str
def load_store_serials(store_name, serials_list): settings["serial1"] = None settings["serial2"] = None settings["device-name1"] = None settings["device-name2"] = None settings["serial"] = None settings["device-name"] = None serial_count = 0 for item in serials_list: if store_name == item["Network name"]: if settings["serial1"]: settings["serial2"] = item["Serial"] settings["device-name2"] = item["Name"] serial_count += 1 else: settings["serial1"] = item["Serial"] settings["device-name1"] = item["Name"] serial_count += 1 if serial_count > 2: logger.error("store {} has too many serial".format(store_name)) runlogs_logger.error( "store {} has too many serial".format(store_name)) gv.fake_assert() return 0 return serial_count
def to_json(self, fname, path="data", absolute_path=None): self.item = {} if absolute_path: fname_csv = "{}/{}.csv".format(absolute_path, fname) fname_json = "{}/{}.json".format(absolute_path, fname) else: fname_csv = utils.get_path(fname, path, "csv") entries = [] try: with open(fname_csv, encoding="windows-1251", newline='') as csv_file: reader = csv.DictReader(csv_file, skipinitialspace=True) for entry in reader: entries.append(entry) item = entry.get("syslogEnabled") if item: if item.lower() == "true": entry["syslogEnabled"] = True else : entry["syslogEnabled"] = False #self.Schema.validate(entry) if absolute_path: Json().writer_full_path(fname_json, entries) else: Json().writer(fname, entries, path) except Exception as err: l.logger.error("fname: {} not found".format(fname)) l.runlogs_logger.error("fname: {} not found".format(fname)) gv.EOM() gv.fake_assert() return entries
def perform_bulk_get_firewall(agent, fn_get, org_name, store_list): fname = store_list store_list = Json.reader(fname, "templates") for store in store_list: store_name = store.get("name", None) if store_name is None: str = "fname: {} ::: name field was not found for store {}".format( fname, store) l.runlogs_logger.error(str) l.logger.error(str) gv.fake_assert() auto_globals.select_store(store_name) try: success = auto_globals.load_store(agent, store_name) assert (success) str = ('getting l3fwrules for {}'.format(store_name)) l.logger.info(str) l.runlogs_logger.info(str) fn_get(agent) str = ('got l3fwrules for {}'.format(store_name)) l.logger.info(str) l.runlogs_logger.info(str) except: str = "failed getting l3fwrules for store : {}".format(store_name) l.logger.error(str) l.runlogs_logger.error(str) gv.fake_assert()
def delete(self, netid, vlanid): self.vlans = None try: success, self.vlans = meraki.delvlan(config.api_key, netid, vlanid) if success: l.logger.info("deleted vlan {}".format(vlanid)) l.runlogs_logger.info("deleted vlan {}".format(vlanid)) else: l.logger.info( "vlan does not exist vlan {} not deleted".format(vlanid)) l.runlogs_logger.info( "vlan does not exist vlan {} not deleted".format(vlanid)) gv.fake_assert() l.logger.debug("netid:{} vlanid:{}".format(netid, vlanid)) except (meraki.EmailFormatError, meraki.OrgPermissionError, meraki.ListError) as err: l.logger.error("Meraki error: {}".format(err.default)) l.runlogs_logger.error("Meraki error: {}".format(err.default)) exit(-1) except Exception as err: l.logger.error("exception failure netid:{} - vlanid:{}".format( netid, vlanid)) l.runlogs_logger.error( "exception failure - vlanid {}".format(vlanid)) gv.fake_assert()
def perform_bulk_delete_vlans(agent, org_name, fname, fn_deploy, vlans_only=False): store_list = Json.reader(fname, "templates") if not goahead_confirm("stores"): return for store in store_list: store_name = store.get("name", None) l.runlogs_logger.info("deploying network: {}".format(store_name)) if store_name is None: str = "fname: {} ::: store_name field was not found for store {}".format( fname, store) l.logger.error(str) l.runlogs_logger.error(str) gv.fake_assert() l.logger.info("deploying store : {}".format(store_name)) auto_globals.select_store(store_name) if (auto_globals.load_store(agent, store_name)) is False: l.logger.error("failed deploying network: {}".format(store_name)) l.runlogs_logger.error( "failed deploying network: {}".format(store_name)) return fn_deploy(agent, vlans_only) l.logger.info("deployed store : {}".format(store_name)) Json.writer(fname, store_list, "templates") Csv.transform_to_csv(fname, None, path="templates") l.runlogs_logger.info("deployed network: {} netid: {}".format( store_name, settings["netid"]))
def getCreatedNetworkId(networkName): fname = "network_{}".format(networkName) network = Json.reader(fname) if network is None: logger.error("unable to load rules from firewall_template") runlogs_logger.error("unable to load rules from firewall_template") gv.fake_assert() return network["id"]
def __init__(self, org_id=None): if org_id == None: org_id = settings["org-id"] success, self.stores = self.list(org_id) if not success: log.logger.error("failed. orgid:{}".format(org_id)) log.runlogs_logger.error("failed. orgid:{}".format(org_id)) gv.fake_assert()
def json_writer(fpath, data): str = make_pretty(data) try: with open(fpath, 'w') as f: f.write(str) except Exception as err: logger.error("failure") runlogs_logger.error("failure") gv.fake_assert()
def writer_full_path(self, fname, data): str = self.make_pretty(data) try: with open(fname, 'w') as f: json_data=f.write(str) except Exception as err: l.logger.error("exception failure") l.runlogs_logger.error("exception failure") gv.fake_assert()
def delete_vlans_list(self, vlans, netid): try: for vlanid in vlans: self.delete(netid, vlanid) except Exception as err: l.logger.error("{}".format(err.args)) l.runlogs_logger.error("{}".format(err.args)) gv.fake_assert() return False return True
def create_update_vlans_list(self, netid, update_flag=True): fname = "vlans_generated_{}".format(netid) vlans_to_deploy = json.reader(fname) self.get_vlans(netid) vlans_deployed = [] for item in self.vlans: id = int(item['id']) vlans_deployed.append(id) deploy_count = 0 for vlan in vlans_to_deploy: id = int(vlan['id']) if id not in vlans_deployed: try: apikey = config.api_key networkid = netid name = vlan['name'] vlanid = id subnet = vlan['subnet'] mxip = vlan['applianceIp'] success, str = meraki.addvlan(apikey, networkid, vlanid, name, subnet, mxip, suppressprint=True) l.logger.info("created vlan {}".format(id)) l.runlogs_logger.info("created vlan {} netid {}".format( id, networkid)) self.update_single_vlan(vlan, update_all=True) deploy_count += 1 except (meraki.EmailFormatError, meraki.OrgPermissionError, meraki.ListError) as err: l.logger.error("Meraki error: {} netid {}".format( err.default, vlanid)) l.runlogs_logger.error("Meraki error: {}".format( err.default)) exit(-1) except Exception as err: l.logger.error("{}".format(err.args)) l.runlogs_logger.error("{}".format(err.args)) gv.fake_assert() if deploy_count == 0: l.logger.info("vlans already exist - no vlans added") l.runlogs_logger.info("vlans already exist - no vlans added") else: l.logger.info("added a total of {} vlans".format(deploy_count)) l.runlogs_logger.info( "added a total of {} vlans".format(deploy_count))
def json_reader(fpath): data = None try: json_data = open(fpath).read() # json_data = json_data.replace("\n","") data = json.loads(json_data) str = make_pretty(data) except Exception as err: # l.logger.error("exception failure fpath:{} {}".format(fpath)) # l.runlogs_logger.error("exception failure fpath:{} {}".format(fpath)) gv.fake_assert() return data
def get_addr(self, host): try: res = socket.gethostbyname(host) return res except: from utils.auto_config import dryrun_netx_fake_ip, dryrun if dryrun: return settings["dryrun-netx-fake-ip"] log.logger.error("Cannot reach store/device : {}".format(host)) log.runlogs_logger.error( "Cannot reach store/device : {}".format(host)) gv.fake_assert()
def json_writer(fpath): data = None try: json_data = open(fpath).write() # json_data = json_data.replace("\n","") data = json.loads(json_data) str = make_pretty(data) l.logger.debug("auto_utils.json_reader:\n{}".format(str)) except Exception as err: l.logger.error("fpath:{} {}".format(fpath)) l.runlogs_logger.error("fpath:{} {}".format(fpath)) gv.fake_assert() return data
def json_reader(fpath): data = None cwd = os.getcwd() try: json_data = open(fpath).read() # json_data = json_data.replace("\n","") data = json.loads(json_data) except Exception as err: logger.error("cwd {} fpath {}".format(cwd, fpath)) runlogs_logger.error("cwd {} fpath {}".format(cwd, fpath)) gv.fake_assert() return data
def update_vlans_list(self, vlans): apikey = config.api_key _err = None try: for vlan in vlans: self.update_single_vlan(vlan) except Exception as err: l.logger.error("{}".format(err.args)) l.runlogs_logger.error("{}".format(err.args)) gv.fake_assert() return False return True
def reader(self, fname, path="data"): data = None try : fnameJson = utils.get_path(fname, path, "json") json_data=open(fnameJson).read() # json_data = json_data.replace("\n","") data = json.loads(json_data) #l.logger.debug("data: {}".format(data)) except Exception as err: l.logger.error("exception failure fname:{} {}".format(fname, fnameJson)) l.runlogs_logger.error("exception failure fname:{} {}".format(fname, fnameJson)) gv.fake_assert() return data
def render_template(self, template_filename, context): str = None try: str = TEMPLATE_ENVIRONMENT.get_template(template_filename).render( context) except Exception as err: l.logger.error("template_filename:{} {}".format( template_filename, err)) l.runlogs_logger.error("template_filename:{} {}".format( template_filename, err)) gv.fake_assert() os._exit(-1) result = json.loads(str) return result
def deln(self, networkid): success = False str = None try: success, str = meraki.delnetwork(config.api_key, networkid) logger.info("success {}".format(networkid)) if not success: logger.error("failed netid {}".format(networkid)) gv.fake_assert() except Exception as err: logger.error("exception failure netid {} {}".format( networkid, str)) runlogs_logger.error("exception failure netid {} {}".format( networkid, str)) gv.fake_assert() return success, str
def getdetail(self, networkid): success = False self.network = None try: success, self.network = meraki.getnetworkdetail( config.api_key, networkid) log.logger.debug(Json.make_pretty(self.network)) if not success: log.logger.error("failed: {}".format(self.network)) log.runlogs_logger.error("failed: {}".format(self.network)) gv.fake_assert() except Exception as err: logger.error("exception failure networkid: {} {}".format( networkid, self.network)) runlogs_logger.error("exception failure {}".format(self.network)) gv.fake_assert() return success, self.network
def convert_json_to_csv(self, fname): _fname = fname.split(".") fname = _fname[0] if len(_fname) > 1: if (_fname[1] != "json"): print("Invalid file name, must end with json and be in home directory.") gv.fake_assert() os.chdir("{}/automation".format(self.cwd)) from utils.auto_csv import convert_to_csv_and_validate if os.name == 'nt': input_path = output_path = "c:\\nsmk\\xfer" else: input_path = "/appl/nsmk/xfer/" output_path = input_path convert_to_csv_and_validate(fname, input_path, output_path) os.chdir("{}".format(self.cwd)) print("{}.csv has been created in {}\n".format(fname, output_path)) EOM()
def set(self, netid, fw_rules, store_number): success = False str = None try: fwrules = json.reader("l3fwrules_deploy_{}".format(store_number)) success, str = meraki.updatemxl3fwrules(config.api_key, netid, fwrules) log.logger.info("success netid {} {}".format(netid, str)) if not success: log.logger.error("failed netid {} {}".format(netid, str)) log.runlogs_logger.error("failed {} {}".format(netid, str)) gv.fake_assert() except Exception as err: log.logger.error("exception failure netid {}\n{}".format( netid, str)) log.runlogs_logger.error("exception failure netid {}\n{}".format( netid, str)) gv.fake_assert() return success, str
def add(self, orgid, name, nettype): success = False self.network = None try: clone_id = config.get_clone_id() success, self.network = meraki.addnetwork(config.api_key, orgid, name, nettype, tags=None, tz="US/Pacific", cloneid=clone_id, suppressprint=False) store_number = settings["store-number"] fname = "network_{}".format(store_number) data = dict() data["store-name"] = settings["store-name"] data["netid"] = settings["netid"] data["clone-source"] = settings["CLI"]["networks-clone-source"] json.writer(fname, data, path="data", header=None, logPath=False) if success: logger.info("success org-id {} {} {} {}".format( orgid, name, nettype, self.network)) else: logger.error("failed org-id {} {} {} {}".format( orgid, name, nettype, self.network)) runlogs_logger.error("failed org-id {} {} {}".format( orgid, name, nettype, self.network)) gv.fake_assert() logger.debug("cloned network, {} {} {}".format( name, nettype, self.network)) except Exception as err: logger.error("orgid {} name {} nettype {}".format( orgid, name, nettype)) runlogs_logger.error("orgid {} name {} nettype {}".format( orgid, name, nettype)) gv.fake_assert() assert (0) return success, self.network
def load_store(_orchestration_agent, store_name): org_name = settings["org-name"] load_org(_orchestration_agent, org_name) store_name = "{}".format(store_name) settings["store-name"] = store_name store_number = utils.obtain_store_number(store_name) settings["store-number"] = store_number settings["time-stamp"] = utils.create_store_data_dir(_orchestration_agent) settings["netid"] = utils.obtain_netid(store_number, store_name) if not settings["netid"]: logger.error("store '{}' not found in org: {}".format( settings["store-name"], settings["org-name"])) runlogs_logger.error("store '{}' not found in org: {}".format( settings["store-name"], settings["org-name"])) runlogs_logger.error("store '{}' not found in org: {}".format( settings["store-name,"], settings["org-name"])) gv.fake_assert() return False # men_and_mice.get_vlan_funnel() set_cli_selections() return True