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