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
