def run_webhook(netpalm_task_result=False, netpalm_webhook_args=False): try: if netpalm_task_result: if netpalm_webhook_args: netpalm_task_result["webhook_args"] = netpalm_webhook_args # convert to json pl = json.dumps(netpalm_task_result) #prepare requests data url_val = config().default_webhook_url headers_val = config().default_webhook_headers verify_val = config().default_webhook_ssl_verify timeout_val = config().default_webhook_timeout pl = pl #execute request response = requests.request("POST", url=url_val, headers=headers_val, verify=verify_val, timeout=timeout_val, data=pl) if str(response.status_code)[:1] != "2": return False else: return True else: return False except Exception as e: return e
def removetemplate(self): try: file_path = config().txtfsm_index_file.replace('index', '') fn = self.kwarg["template"] fl = file_path + fn os.remove(fl) #update index rewrite_data = [] with open(self.indexfile, 'r+') as f: #r+ does the work of rw for line in f: if not line.startswith(self.kwarg["template"]): rewrite_data.append(line) tmpfile = config().txtfsm_index_file+'.tmp' with open(tmpfile, 'w') as f: for ln in rewrite_data: f.write("%s" % ln) #reload indexfile shutil.move(tmpfile, config().txtfsm_index_file) resultdata = { 'status': 'success', 'data': { "task_result": self.kwarg["template"] + ' removed' } } return resultdata except Exception as e: resultdata = { 'status': 'error', 'data': str(e) } return resultdata
def pinned_worker(queue): try: with Connection(Redis(host=config().redis_server,port=config().redis_port,password=config().redis_key)): q = Queue(queue) worker = Worker(q) worker.work() except Exception as e: return e
def processworker(): try: with Connection(Redis(config().redis_server, config().redis_port)): q = Queue(config().redis_core_q) worker = Worker(q) worker.work() except Exception as e: return e
def pinned_worker(queue): try: with Connection(Redis(config().redis_server, config().redis_port)): q = Queue(queue) worker = Worker(q) worker.work() except Exception as e: return e
def __init__(self, service=False, **kwargs): self.kwarg = kwargs.get('kwargs', False) if not service: self.jinja_template_dir = config().jinja2_templates elif service: self.jinja_template_dir = config().jinja2_service_templates self.file_loader = FileSystemLoader(self.jinja_template_dir) self.env = Environment(loader=self.file_loader)
def __init__(self): #globals self.server = config().redis_server self.port = config().redis_port self.ttl = config().redis_task_ttl self.timeout = config().redis_task_timeout self.routes = routes.routes self.core_q = config().redis_core_q self.base_connection = Redis(self.server, self.port) self.base_q = Queue(self.core_q, connection=self.base_connection) self.queuedb = {}
async def get_api_key( api_key_query: str = Security(api_key_query), api_key_header: str = Security(api_key_header), api_key_cookie: str = Security(api_key_cookie), ): if api_key_query == config().api_key: return api_key_query elif api_key_header == config().api_key: return api_key_header elif api_key_cookie == config().api_key: return api_key_cookie else: raise HTTPException( status_code=HTTP_403_FORBIDDEN, detail="Could not validate credentials" )
def addtemplate(self): try: #prepare args downloadf = self.kwarg["key"].split('_')[0] command = self.kwarg["command"].replace(' ','_') file_name = self.kwarg["driver"] + '_' + command + '.template' file_path = config().txtfsm_index_file.replace('index', '') fn = file_path + file_name #get and write with open(fn, "w") as file: response = get(config().txtfsm_template_server+'/static/fsms/'+downloadf+'.txt', timeout=10) file.write(response.text) #update index rewrite_data = [] with open(self.indexfile, 'r+') as f: #r+ does the work of rw count = 0 driver_line = False for line in f: if line.startswith(self.kwarg["driver"]): driver_line = True elif not line.startswith(self.kwarg["driver"]) and driver_line and count == 0: count +=1 rewrite_data.append(file_name+', .*,'+self.kwarg["driver"]+','+self.kwarg["command"]+'\n') rewrite_data.append(line) tmpfile = config().txtfsm_index_file+'.tmp' with open(tmpfile, 'w') as f: for ln in rewrite_data: f.write("%s" % ln) #reload indexfile shutil.move(tmpfile, config().txtfsm_index_file) resultdata = { 'status': 'success', 'data': { "task_result": file_name + ' added' } } return resultdata except Exception as e: resultdata = { 'status': 'error', 'data': str(e) } return resultdata
def __init__(self): #globals self.server = config().redis_server self.port = config().redis_port self.ttl = config().redis_task_ttl self.timeout = config().redis_task_timeout self.routes = routes.routes self.core_q = config().redis_core_q self.base_connection = Redis(self.server, self.port) self.base_q = Queue(self.core_q, connection=self.base_connection) self.networked_queuedb = config().redis_queue_store self.local_queuedb = {} self.local_queuedb[config().redis_fifo_q] = {} self.local_queuedb[config().redis_fifo_q]["queue"] = Queue(config().redis_fifo_q, connection=self.base_connection)
def __init__(self): #globals self.server = config().redis_server self.port = config().redis_port self.key = config().redis_key self.ttl = config().redis_task_ttl self.timeout = config().redis_task_timeout self.routes = routes.routes self.core_q = config().redis_core_q self.base_connection = Redis(host=self.server, port=self.port, password=self.key) self.base_q = Queue(self.core_q, connection=self.base_connection) self.networked_queuedb = config().redis_queue_store self.local_queuedb = {} self.local_queuedb[config().redis_fifo_q] = {} self.local_queuedb[config().redis_fifo_q]["queue"] = Queue( config().redis_fifo_q, connection=self.base_connection) net_db_exists = self.base_connection.get(self.networked_queuedb) if not net_db_exists: nulldb = json.dumps({"netpalm-db": "queue-val"}) self.base_connection.set(self.networked_queuedb, nulldb)
def execute_task(self, method, **kwargs): try: kw = kwargs.get("kwargs", False) connectionargs = kw.get("connection_args", False) if connectionargs: host = kw["connection_args"].get("host", False) queue_strategy = kw.get("queue_strategy", False) if queue_strategy == "pinned": self.check_and_create_q_w(hst=host) r = self.sendtask(q=host,exe=method,kwargs=kw) else: r = self.sendtask(q=config().redis_fifo_q,exe=method,kwargs=kw) return r except Exception as e: return e
def __init__(self, **kwargs): self.kwarg = kwargs.get('kwargs', False) self.jinja_template_dir = config().jinja2_templates
def __init__(self, **kwargs): self.scrp_path = config().custom_scripts self.kwarg = kwargs.get('kwargs', False) self.arg = self.kwarg.get('args', False) self.script = self.kwarg.get('script', False) self.script_name = self.scrp_path.replace('/', '.') + self.script
def fifo_worker_constructor(queue): for i in range(config().fifo_process_per_node): p = Process(target=fifo_worker, args=(queue, )) p.start()
from redis import Redis import redis from rq import Queue, Connection, Worker from rq.job import Job import json from multiprocessing import Process from backend.core.confload.confload import config def fifo_worker(queue): try: with Connection( Redis(host=config().redis_server, port=config().redis_port, password=config().redis_key)): q = Queue(queue) worker = Worker(q) worker.work() except Exception as e: return e def fifo_worker_constructor(queue): for i in range(config().fifo_process_per_node): p = Process(target=fifo_worker, args=(queue, )) p.start() fifo_worker_constructor(config().redis_fifo_q)
def __init__(self): self.api_key = config().apikey self.listen_ip = config().listen_ip self.listen_port = config().listen_port self.self_api_call_timeout = config().self_api_call_timeout self.operation_mapping = { 'create': 'setconfig', 'delete': 'setconfig', 'retrieve': 'getconfig' } self.service_schema = service = { "$schema": "http://json-schema.org/draft-07/schema", "$id": "http://example.com/example.json", "type": "array", "title": "The Root Schema", "description": "The root schema comprises the entire JSON document.", "items": { "$id": "#/items", "type": "object", "title": "The Items Schema", "description": "An explanation about the purpose of this instance.", "default": {}, "examples": [ { "supported_methods": [ { "operation": "create", "payload": {} } ] } ], "required": [ "supported_methods" ], "properties": { "supported_methods": { "$id": "#/items/properties/supported_methods", "type": "array", "title": "The Supported_methods Schema", "description": "An explanation about the purpose of this instance.", "default": [], "items": { "$id": "#/items/properties/supported_methods/items", "type": "object", "title": "The Items Schema", "description": "An explanation about the purpose of this instance.", "default": {}, "examples": [ { "operation": "create", "payload": {} } ], "required": [ "operation", "payload" ], "properties": { "operation": { "$id": "#/items/properties/supported_methods/items/properties/operation", "type": "string", "title": "The Operation Schema", "description": "defines the purpose of the operation, eg create retrieve delete", "default": "", "examples": [ "create", "update", "dete" ] }, "payload": { "$id": "#/items/properties/supported_methods/items/properties/payload", "type": "object", "title": "The Payload Schema", "description": "An explanation about the purpose of this instance.", "default": {}, "examples": [ {} ] } } } } } } }
except Exception as e: return redirect(url_for('error', error=str(e), status_code=500)) pass @app.route("/service/<servicename>", methods=['POST']) @login_required def runservice(servicename=None): try: if request.method == 'POST' and servicename: req_data = request.get_json() r = routes["render_service"](servicename, kwargs=req_data) resp = jsonify(r) return resp, 201 #return redirect(url_for('error', error="GET required", status_code=500)) except Exception as e: return redirect(url_for('error', error=str(e), status_code=500)) pass if __name__ == '__main__': processworkerprocess() reds = rediz() os.system( 'ln -sf /usr/local/lib/python3.8/site-packages/ntc_templates/templates/ backend/plugins/ntc-templates' ) app.run(host=config().listen_ip, port=config().listen_port, debug=True, threaded=True)
async def route_logout_and_remove_cookie(): response = RedirectResponse(url="/") response.delete_cookie(config().api_key_name, domain=config().cookie_domain) response.delete_cookie("Authorization", domain=config().cookie_domain) return response
from fastapi.security.api_key import APIKeyQuery, APIKeyCookie, APIKeyHeader, APIKey from fastapi import Security, Depends, FastAPI, HTTPException from starlette.status import HTTP_403_FORBIDDEN from backend.core.confload.confload import config api_key_query = APIKeyQuery(name=config().api_key_name, auto_error=False) api_key_header = APIKeyHeader(name=config().api_key_name, auto_error=False) api_key_cookie = APIKeyCookie(name=config().api_key_name, auto_error=False) async def get_api_key( api_key_query: str = Security(api_key_query), api_key_header: str = Security(api_key_header), api_key_cookie: str = Security(api_key_cookie), ): if api_key_query == config().api_key: return api_key_query elif api_key_header == config().api_key: return api_key_header elif api_key_cookie == config().api_key: return api_key_cookie else: raise HTTPException( status_code=HTTP_403_FORBIDDEN, detail="Could not validate credentials" )
return resp, 200 else: return redirect(url_for('error', error="host not foud", status_code=404)) except Exception as e: return redirect(url_for('error', error=str(e), status_code=500)) pass #read config @app.route("/getconfig", methods = ['POST']) @login_required def getconfig(): try: if request.method == 'POST': req_data = request.get_json() host = req_data.get("host", False) reds.check_and_create_q_w(hst=host) r = reds.sendtask(q=host,exe='getconfig',kwargs=req_data) resp = jsonify(r) return resp, 201 else: return redirect(url_for('error', error="POST required", status_code=500)) except Exception as e: return redirect(url_for('error', error=str(e), status_code=500)) pass if __name__ == '__main__': processworkerprocess() reds = rediz() app.run(host=config().listen_ip, port=config().listen_port, debug=True, threaded=True)
def __init__(self, **kwargs): self.kwarg = kwargs.get('kwargs', False) self.indexfile = config().txtfsm_index_file
def decorated_function(*args, **kwargs): if request.headers.get('x-api-key') and request.headers.get('x-api-key') == config().apikey: return view_function(*args, **kwargs) else: return redirect(url_for('denied'))
def __init__(self, webhook_name, webhook_args): self.webhook_dir_path = config().custom_webhooks if not webhook_name: self.webhook_name_raw = config().default_webhook_name self.webhook_name = self.webhook_dir_path.replace("/",".") + webhook_name self.webhook_args = webhook_args