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
