def config(self, session=False, command=False):
try:
result = {}
url = self.transport + "://" + self.host + ":" + str(
self.port) + self.kwarg["uri"]
if hasattr(requests, str(self.action)):
response = getattr(requests, str(self.action))(
url,
auth=(self.username, self.password),
data=json.dumps(self.payload),
params=self.params,
headers=self.headers,
**self.connection_args)
try:
res = json.loads(response.text)
except Exception:
res = ""
pass
result[url] = {}
result[url]["status_code"] = response.status_code
result[url]["result"] = res
return result
else:
raise Exception(self.action + " not found in requests")
except Exception as e:
write_meta_error(f"{e}")
def connect(self):
try:
log.info(self.connection_args)
conn = manager.connect(**self.connection_args)
return conn
except Exception as e:
write_meta_error(f"{e}")
def editconfig(self, session=False, dry_run=False):
try:
result = {}
if self.kwarg:
rjsflag = False
if "render_json" in self.kwarg:
if self.kwarg.get("render_json"):
rjsflag = True
del self.kwarg["render_json"]
# edit_config returns an RPCReply object which doesnt have a
# data_xml property. Fixes 'Unserializable return value'
# message from rq.job:restore
response = session.edit_config(**self.kwarg).xml
if dry_run:
session.discard_changes()
else:
session.commit()
if rjsflag:
respdict = xmltodict.parse(response)
if respdict:
result["edit_config"] = respdict
else:
write_meta_error_string("failed to parse response")
else:
result["edit_config"] = response
else:
write_meta_error_string("args are required")
return result
except Exception as e:
write_meta_error(e)
def connect(self):
try:
driver = napalm.get_network_driver(self.driver)
napalmses = driver(**self.connection_args)
return napalmses
except Exception as e:
write_meta_error(f"{e}")
def config(self,
session=False,
command='',
enter_enable=False,
dry_run=False):
try:
if type(command) == list:
comm = command
else:
comm = command.splitlines()
if enter_enable:
session.enable()
if self.kwarg:
response = session.send_config_set(comm, **self.kwarg)
else:
response = session.send_config_set(comm)
if not dry_run:
response += self.try_commit_or_save(session)
result = {}
result["changes"] = response.split("\n")
return result
except Exception as e:
write_meta_error(e)
def connect(self):
try:
if not self.headers:
self.headers = self.default_headers
else:
del self.connection_args["headers"]
return True
except Exception as e:
write_meta_error(f"{e}")
def render_service(**kwargs):
"""Main procedure for rendering and executing service & subtasks"""
templat = kwargs.get("service_model")
exeservice = None
try:
s = service(kw=kwargs)
res = s.validate_template(template_name=templat)
if res:
exeservice = s.execute_service()
except Exception as e:
write_meta_error(f"render_service: {e}")
return exeservice
def sendcommand(self, session=False, command=False):
try:
result = {}
session.open()
for c in command:
if hasattr(session, str(c)):
response = getattr(session, str(c))()
result[c] = response
else:
response = session.cli([c])
result[c] = response[c].split("\n")
return result
except Exception as e:
write_meta_error(f"{e}")
def sendcommand(self, session=False, command=False):
try:
result = {}
for commands in command:
if self.kwarg:
response = session.send_command(commands, **self.kwarg)
if response:
result[commands] = response
else:
response = session.send_command(commands)
if response:
result[commands] = response.split("\n")
return result
except Exception as e:
write_meta_error(f"{e}")
def sendcommand(self, session=False, command=False):
try:
result = {}
for c in command:
# remove timeout weirdness for tables
if self.input_args["type"] == "table":
response = getattr(puresnmp, self.input_args["type"])(
ip=self.connection_args["host"],
community=self.connection_args["community"],
oid=c,
port=self.connection_args["port"])
else:
response = getattr(puresnmp, self.input_args["type"])(
ip=self.connection_args["host"],
community=self.connection_args["community"],
oid=c,
port=self.connection_args["port"],
timeout=self.connection_args["timeout"],
)
# remnder result data for get call
if self.input_args["type"] == "get":
if isinstance(response, bytes):
response = response.decode(errors="ignore")
result[c] = response
# remnder result data for walk call
elif self.input_args["type"] == "walk":
result[c] = []
for row in response:
oid = str(row[0])
oid_raw = row[1]
if isinstance(oid_raw, bytes):
oid_raw = oid_raw.decode(errors="ignore")
result[c].append({oid: oid_raw})
# remnder result data for table call
elif self.input_args["type"] == "table":
result[c] = []
for key in response[0]:
oid = str(key)
oid_raw = response[0][key]
if isinstance(response[0][key], bytes):
oid_raw = oid_raw.decode(errors="ignore")
result[c].append({oid: oid_raw})
else:
result[c] = f"{response}"
return result
except Exception as e:
write_meta_error(f"{e}")
def dryrun(**kwargs):
lib = kwargs.get("library", False)
config = kwargs.get("config", False)
j2conf = kwargs.get("j2config", False)
webhook = kwargs.get("webhook", False)
enable_mode = kwargs.get("enable_mode", False)
result = False
try:
write_mandatory_meta()
if j2conf:
j2confargs = j2conf.get("args")
res = render_j2template(j2conf["template"],
template_type="config",
kwargs=j2confargs)
config = res["data"]["task_result"]["template_render_result"]
result = {}
if lib == "napalm":
napl = naplm(**kwargs)
sesh = napl.connect()
result = napl.config(session=sesh, command=config, dry_run=True)
napl.logout(sesh)
elif lib == "ncclient":
# if we rendered j2config, add it to the kwargs['args'] dict
if j2conf and config:
if not kwargs.get('args', False):
kwargs['args'] = {}
kwargs['args']['config'] = config
ncc = ncclien(**kwargs)
sesh = ncc.connect()
result = ncc.editconfig(session=sesh, dry_run=True)
ncc.logout(sesh)
elif lib == "netmiko":
netmik = netmko(**kwargs)
sesh = netmik.connect()
result = netmik.config(sesh, config, enable_mode, dry_run=True)
netmik.logout(sesh)
if webhook:
current_jobdata = render_netpalm_payload(job_result=result)
exec_webhook_func(jobdata=current_jobdata, webhook_payload=webhook)
except Exception as e:
write_meta_error(e)
return result
def editconfig(self, session=False, dry_run=False):
try:
result = {}
if self.kwarg:
response = session.edit_config(**self.kwarg)
if dry_run:
session.discard_changes()
else:
session.commit()
if response:
result["edit_config"] = response
else:
write_meta_error("args are required")
return result
except Exception as e:
write_meta_error(f"{e}")
def script_exec(**kwargs):
webhook = kwargs.get("webhook", False)
result = False
try:
write_mandatory_meta()
scrip = script_kiddy(kwargs=kwargs)
result = scrip.s_exec()
if webhook:
current_jobdata = render_netpalm_payload(job_result=result)
exec_webhook_func(jobdata=current_jobdata, webhook_payload=webhook)
except Exception as e:
write_meta_error(e)
return result
def validate_template(self, template_name):
try:
args = self.posted_kwargs.get("args", None)
# redner the j2 template
rendered_template = render_j2template(templat=template_name,
template_type="service",
kwargs=args)
# get the rendered data as json
data = json.loads(rendered_template["data"]["task_result"]
["template_render_result"])
# double check the template complies with the base model
ServiceModelTemplate(__root__=data)
self.template_json = data
return True
except Exception as e:
write_meta_error(f"validate_template: {e}")
log.error(f"validate_template: {e}")
def ncclient_get(**kwargs):
"""main function for executing getconfig commands to southbound drivers"""
lib = kwargs.get("library", False)
result = False
try:
result = {}
if lib == "ncclient":
ncc = ncclien(**kwargs)
sesh = ncc.connect()
result = ncc.getmethod(sesh)
ncc.logout(sesh)
else:
raise NotImplementedError(f"unknown 'library' parameter {lib}")
except Exception as e:
write_meta_error(f"{e}")
return result
def config(self, session=False, command=False, dry_run=False):
try:
if type(command) == list:
napalmconfig = ""
for comm in command:
napalmconfig += comm + "\n"
else:
napalmconfig = command
session.open()
session.load_merge_candidate(config=napalmconfig)
diff = session.compare_config()
if dry_run:
response = session.discard_config()
else:
response = session.commit_config()
result = {}
result["changes"] = diff.split("\n")
return result
except Exception as e:
write_meta_error(f"{e}")
def sendcommand(self, session=False, command=False):
try:
result = {}
for commands in command:
if self.kwarg:
# normalise the ttp template name for ease of use
if "ttp_template" in self.kwarg.keys():
if self.kwarg["ttp_template"]:
template_name = config.ttp_templates + self.kwarg[
"ttp_template"] + ".ttp"
self.kwarg["ttp_template"] = template_name
response = session.send_command(commands, **self.kwarg)
if response:
result[commands] = response
else:
response = session.send_command(commands)
if response:
result[commands] = response.split("\n")
return result
except Exception as e:
write_meta_error(f"{e}")
def getconfig(self, session=False, command=False):
try:
result = {}
if self.kwarg:
rjsflag = False
if self.kwarg.get("render_json", False):
del self.kwarg["render_json"]
rjsflag = True
# check whether RPC required
if self.kwarg.get("rpc", False):
response = session.rpc(**self.kwarg).data_xml
# else a standard get_config method call
else:
response = session.get_config(**self.kwarg).data_xml
if rjsflag:
respdict = xmltodict.parse(response)
if respdict:
result["get_config"] = respdict
else:
write_meta_error("failed to parse response")
else:
result["get_config"] = response
else:
write_meta_error("args are required")
return result
except Exception as e:
write_meta_error(f"{e}")
def sendcommand(self, session=False, command=False):
try:
# restconf get call
result = {}
url = self.transport + "://" + self.host + ":" + str(
self.port) + self.kwarg["uri"]
response = requests.get(url,
auth=(self.username, self.password),
params=self.params,
headers=self.headers,
**self.connection_args)
try:
res = json.loads(response.text)
except Exception:
res = ""
pass
result[url] = {}
result[url]["status_code"] = response.status_code
result[url]["result"] = res
return result
except Exception as e:
write_meta_error(f"{e}")
def execute_api_call(self, oper, payload):
"""API call handler for posting service subtasks"""
try:
# update config to include https when finished webserver bundle
headers = {
"x-api-key": self.api_key,
"Content-Type": "application/json"
}
# post to service api
res = requests.post(
f"{config.netpalm_callback_http_mode}://{self.netpalm_container_name}:{self.listen_port}{oper}",
data=payload,
timeout=self.self_api_call_timeout,
headers=headers)
if res.status_code == 201:
return res.json()
else:
write_meta_error(
f"error calling self api response {res.status_code}")
except Exception as e:
write_meta_error(f"execute_api_call service: {e}")
log.error(f"execute_api_call service: {e}")
def getmethod(self, session=False, command=False):
try:
result = {}
if self.kwarg:
rjsflag = False
if "render_json" in self.kwarg:
if self.kwarg.get("render_json"):
rjsflag = True
del self.kwarg["render_json"]
response = session.get(**self.kwarg).data_xml
if rjsflag:
respdict = xmltodict.parse(response)
if respdict:
result["get_config"] = respdict
else:
write_meta_error_string("failed to parse response")
else:
result["get_config"] = response
else:
write_meta_error_string("args are required")
return result
except Exception as e:
write_meta_error(e)
def config(self,
session=False,
command='',
enter_enable=False,
dry_run=False):
try:
if type(command) == list:
comm = command
else:
comm = command.splitlines()
if enter_enable:
session.enable()
if self.kwarg:
response = session.send_config_set(comm, **self.kwarg)
else:
response = session.send_config_set(comm)
if not dry_run:
# CiscoBaseConnection(BaseConnection)
# implements commit and save_config in child classes
if hasattr(session, "commit") and callable(session.commit):
try:
if self.commit_label:
response += session.commit(label=self.commit_label)
else:
response += session.commit()
except AttributeError:
pass
except Exception as e:
write_meta_error(f"{e}")
elif hasattr(session, "save_config") and callable(
session.save_config):
try:
response += session.save_config()
except AttributeError:
pass
except Exception as e:
write_meta_error(f"{e}")
result = {}
result["changes"] = response.split("\n")
return result
except Exception as e:
write_meta_error(f"{e}")
def getconfig(self, session=False, command=False):
try:
result = {}
if self.kwarg:
render_json = self.kwarg.get("render_json", False)
rjsflag = False
if render_json:
del self.kwarg["render_json"]
rjsflag = True
response = session.get_config(**self.kwarg).data_xml
if rjsflag:
respdict = xmltodict.parse(response)
if respdict:
result["get_config"] = respdict
else:
write_meta_error("no response")
else:
result["get_config"] = response
else:
write_meta_error("args are required")
return result
except Exception as e:
write_meta_error(f"{e}")
def logout(self, session):
try:
response = session.close_session()
return response
except Exception as e:
write_meta_error(f"{e}")
def logout(self, session):
try:
response = session.disconnect()
return response
except Exception as e:
write_meta_error(f"{e}")
def connect(self):
try:
netmikoses = ConnectHandler(**self.connection_args)
return netmikoses
except Exception as e:
write_meta_error(f"{e}")
def logout(self, session):
try:
return True
except Exception as e:
write_meta_error(f"{e}")
def config(self, session=False, command=False, dry_run=False):
try:
return True
except Exception as e:
write_meta_error(f"{e}")
def connect(self):
try:
return True
except Exception as e:
write_meta_error(f"{e}")
def exec_command(**kwargs):
"""main function for executing getconfig commands to southbound drivers"""
log.debug(f'called w/ {kwargs}')
lib = kwargs.get("library", False)
command = kwargs.get("command", False)
webhook = kwargs.get("webhook", False)
post_checks = kwargs.get("post_checks", False)
result = False
if type(command) == str:
commandlst = [command]
else:
commandlst = command
if not post_checks:
try:
result = {}
if lib == "netmiko":
netmik = netmko(**kwargs)
sesh = netmik.connect()
result = netmik.sendcommand(sesh, commandlst)
netmik.logout(sesh)
elif lib == "napalm":
napl = naplm(**kwargs)
sesh = napl.connect()
result = napl.sendcommand(sesh, commandlst)
napl.logout(sesh)
elif lib == "ncclient":
ncc = ncclien(**kwargs)
sesh = ncc.connect()
result = ncc.getconfig(sesh)
ncc.logout(sesh)
elif lib == "restconf":
rc = restconf(**kwargs)
sesh = rc.connect()
result = rc.sendcommand(sesh)
rc.logout(sesh)
else:
raise NotImplementedError(f"unknown 'library' parameter {lib}")
except Exception as e:
write_meta_error(f"{e}")
else:
try:
result = {}
if lib == "netmiko":
netmik = netmko(**kwargs)
sesh = netmik.connect()
if commandlst:
result = netmik.sendcommand(sesh, commandlst)
if post_checks:
for postcheck in post_checks:
command = postcheck["get_config_args"]["command"]
post_check_result = netmik.sendcommand(sesh, [command])
for matchstr in postcheck["match_str"]:
if postcheck[
"match_type"] == "include" and matchstr not in str(
post_check_result):
write_meta_error(
f"PostCheck Failed: {matchstr} not found in {post_check_result}"
)
if postcheck[
"match_type"] == "exclude" and matchstr in str(
post_check_result):
write_meta_error(
f"PostCheck Failed: {matchstr} found in {post_check_result}"
)
netmik.logout(sesh)
elif lib == "napalm":
napl = naplm(**kwargs)
sesh = napl.connect()
if commandlst:
result = napl.sendcommand(sesh, commandlst)
if post_checks:
for postcheck in post_checks:
command = postcheck["get_config_args"]["command"]
post_check_result = napl.sendcommand(sesh, [command])
for matchstr in postcheck["match_str"]:
if postcheck[
"match_type"] == "include" and matchstr not in str(
post_check_result):
write_meta_error(
f"PostCheck Failed: {matchstr} not found in {post_check_result}"
)
if postcheck[
"match_type"] == "exclude" and matchstr in str(
post_check_result):
write_meta_error(
f"PostCheck Failed: {matchstr} found in {post_check_result}"
)
napl.logout(sesh)
elif lib == "ncclient":
ncc = ncclien(**kwargs)
sesh = ncc.connect()
result = ncc.getconfig(sesh)
ncc.logout(sesh)
elif lib == "restconf":
rc = restconf(**kwargs)
sesh = rc.connect()
result = rc.sendcommand(sesh)
rc.logout(sesh)
except Exception as e:
write_meta_error(f"{e}")
try:
if webhook:
current_jobdata = render_netpalm_payload(job_result=result)
exec_webhook_func(jobdata=current_jobdata, webhook_payload=webhook)
except Exception as e:
write_meta_error(f"{e}")
return result
