def commit_data(cls, data):
new_obj = None
if isinstance(data, list) or isinstance(data, tuple):
cls.session.add_all(data)
else:
if isinstance(data, dict):
new_obj = cls(**data)
else:
new_obj = data
try:
cls.session.add(new_obj)
cls.session.commit()
result = {
'success': True,
'result': data,
'id': new_obj.id if new_obj else None
}
except:
cls.session.rollback()
result = {'success': False, 'result': traceback_format_exc()}
# cls.session.close()
return result
def fake_interruptible(func, args=None, kwargs=None, timeout=DEFAULT_TIMEOUT):
"""
Fake, non-interruptible, using no threads and no signals
implementation used for debugging. This ignores the timeout and just
the function as-is.
"""
try:
return NO_ERROR, func(*(args or ()), **(kwargs or {}))
except Exception:
return ERROR_MSG + traceback_format_exc(), NO_VALUE
def runner():
try:
_res = func(*(args or ()), **(kwargs or {}))
results.put((
NO_ERROR,
_res,
))
except Exception:
results.put((
ERROR_MSG + traceback_format_exc(),
NO_VALUE,
))
def update_all_radios_tracks(cls):
results = {}
radios = cls.all()
for radio in radios:
try:
res = cls.update_radio_tracks(radio_name=radio.name)
results[radio.name] = res
except:
results['dd'] = {'success': False, 'result': traceback_format_exc()}
return results
def authenticate_event(content):
sid = request.sid
try:
if 'token' not in content:
raise Exception('Json web token introuvable')
authentication_events.authentication(content["token"], sid)
logger.info("[%s] [%s] [%s] [%s] [%s] [%s]", "SOCKET", request.host,
"authenticate", type(content), content, "OK")
except Exception as e:
logger.warning("[%s] [%s] [%s] [%s] [%s] [%s]\n%s", "SOCKET",
request.host, "authenticate", type(content), content,
"ERROR", traceback_format_exc())
emit('error', str(e), room=sid, namepace='/')
def runner():
"""
Run the func and send results back in a queue as a tuple of
(`error`, `value`)
"""
try:
_res = func(*(args or ()), **(kwargs or {}))
results.put((
NO_ERROR,
_res,
))
except Exception:
results.put((
ERROR_MSG + traceback_format_exc(),
NO_VALUE,
))
def interruptible(func, args=None, kwargs=None, timeout=DEFAULT_TIMEOUT):
"""
Windows, threads-based interruptible runner. It can work also on
POSIX, but is not reliable and works only if everything is pickable.
"""
# We run `func` in a thread and block on a queue until timeout
results = Queue()
def runner():
"""
Run the func and send results back in a queue as a tuple of
(`error`, `value`)
"""
try:
_res = func(*(args or ()), **(kwargs or {}))
results.put((
NO_ERROR,
_res,
))
except Exception:
results.put((
ERROR_MSG + traceback_format_exc(),
NO_VALUE,
))
tid = start_new_thread(runner, ())
try:
# wait for the queue results up to timeout
err_res = results.get(timeout=timeout)
if not err_res:
return ERROR_MSG, NO_VALUE
return err_res
except (Queue_Empty, MpTimeoutError):
return TIMEOUT_MSG % locals(), NO_VALUE
except Exception:
return ERROR_MSG + traceback_format_exc(), NO_VALUE
finally:
try:
async_raise(tid, Exception)
except (SystemExit, ValueError):
pass
def message_send_event(content):
sid = request.sid
socket = sockets.find_socket(sid)
try:
if socket is None or socket.authenticated is False:
raise Exception('Socket user introuvable')
b, s = check_json(content, 'conversation_id')
if not b:
raise Exception('Param conversation_id introuvable')
message_send(content["conversation_id"], content, socket)
logger.info("[%s] [%s] [%s] [%s] [%s] [%s]", "SOCKET", request.host,
"message", type(content), content, "OK")
except Exception as e:
logger.warning("[%s] [%s] [%s] [%s] [%s] [%s]\n%s", "SOCKET",
request.host, "message", type(content), content,
"ERROR", traceback_format_exc())
emit('error', str(e), room=sid, namepace='/')
db.session.close()
def leave_circle_event(content):
sid = request.sid
try:
socket = sockets.find_socket(sid)
if socket is None or socket.authenticated is False:
raise Exception('Socket user introuvable')
b, s = check_json(content, 'circle_id')
if not b:
raise Exception('Parameter circle_id missing')
room_events.leave_circle(content["circle_id"], socket)
logger.info("[%s] [%s] [%s] [%s] [%s] [%s]", "SOCKET", request.host,
"leave_circle", type(content), content, "OK")
except Exception as e:
logger.warning("[%s] [%s] [%s] [%s] [%s] [%s]\n%s", "SOCKET",
request.host, "leave_circle", type(content), content,
"ERROR", traceback_format_exc())
emit('error', str(e), room=sid, namepace='/')
db.session.close()
def interruptible(func, args=None, kwargs=None, timeout=DEFAULT_TIMEOUT):
"""
POSIX, signals-based interruptible runner.
"""
def handler(signum, frame):
raise TimeoutError
try:
create_signal(SIGALRM, handler)
setitimer(ITIMER_REAL, timeout)
return NO_ERROR, func(*(args or ()), **(kwargs or {}))
except TimeoutError:
return TIMEOUT_MSG % locals(), NO_VALUE
except Exception:
return ERROR_MSG + traceback_format_exc(), NO_VALUE
finally:
setitimer(ITIMER_REAL, 0)
def update_row(cls, data, create_new=False):
# if call from class
if isinstance(cls, api.DeclarativeMeta):
if cls.unique_search_field not in data.keys():
return {
'success': False,
'result': 'Missing filter_id argument'
}
obj = cls.query(cls).filter(
getattr(cls, cls.unique_search_field) == data[
cls.unique_search_field])
# if call from object
else:
attr = getattr(cls, cls.unique_search_field)
obj = cls.query(cls).filter(
attr == (getattr(cls, cls.unique_search_field)))
if obj.count() == 1:
try:
obj.update(data)
cls.session.commit()
result = {'success': True, 'result': data}
except:
cls.session.rollback()
result = {'success': False, 'result': traceback_format_exc()}
elif obj.count() == 0 and create_new:
return cls.commit_data(data)
else:
result = {
'success': False,
'result':
f'Instead of 1 object - {obj.count()} object was found'
}
# cls.session.close()
return result
def _retension_thread_procedure(self):
log('FileStorage: Retension thread started')
previous_check_time = 0
while True:
try:
now = time_time()
if now - previous_check_time > 10 * 60: # every 10 minutes
log('FileStorage: Check for outdated files')
previous_check_time = time_time()
self._check_retention()
# Wait for 60 seconds with a possibility
# to be interrupted through stop() call:
with self._condition_stop:
if not self._stopping:
self._condition_stop.wait(60)
if self._stopping:
log('Retension thread found stop signal')
break
except Exception:
logging_error(traceback_format_exc())
time_sleep(60) # prevent from flooding
#########################################
# OPEN AUDIO DEVICE
#
#########################################
try:
sd = sounddevice.OutputStream(device=AUDIO_DEVICE_ID,
blocksize=512,
samplerate=44100,
channels=2,
dtype='int16',
callback=AudioCallback)
sd.start()
print("Opened audio device #{}".format(AUDIO_DEVICE_ID))
except Exception:
print("\n[ERROR] {}".format(traceback_format_exc()))
print("Invalid audio device #{}".format(AUDIO_DEVICE_ID))
exit(1)
#########################################
# KEYBOARD THREAD (NEEDS ROOT)
#
#########################################
if USE_KEYBOARD:
from keyboard import read_key as keyboard_read_key
def Keyboard():
global preset
try:
while True:
if keyboard_read_key() == '-':
def deploy(self, session, indata, version, nsr_id, *args, **kwargs):
print("ns.deploy session={} indata={} version={} nsr_id={}".format(
session, indata, version, nsr_id))
validate_input(indata, deploy_schema)
action_id = indata.get("action_id", str(uuid4()))
task_index = 0
# get current deployment
db_nsr = None
# db_nslcmop = None
db_nsr_update = {} # update operation on nsrs
db_vnfrs_update = {}
# db_nslcmop_update = {} # update operation on nslcmops
db_vnfrs = {} # vnf's info indexed by _id
vdu2cloud_init = {}
step = ''
logging_text = "Task deploy nsr_id={} action_id={} ".format(
nsr_id, action_id)
self.logger.debug(logging_text + "Enter")
try:
step = "Getting ns and vnfr record from db"
# db_nslcmop = self.db.get_one("nslcmops", {"_id": nslcmop_id})
db_nsr = self.db.get_one("nsrs", {"_id": nsr_id})
db_ro_tasks = []
db_new_tasks = []
# read from db: vnf's of this ns
step = "Getting vnfrs from db"
db_vnfrs_list = self.db.get_list("vnfrs", {"nsr-id-ref": nsr_id})
if not db_vnfrs_list:
raise NsException("Cannot obtain associated VNF for ns")
for vnfr in db_vnfrs_list:
db_vnfrs[vnfr["_id"]] = vnfr
db_vnfrs_update[vnfr["_id"]] = {}
now = time()
db_ro_nsr = self.db.get_one("ro_nsrs", {"_id": nsr_id},
fail_on_empty=False)
if not db_ro_nsr:
db_ro_nsr = self._create_db_ro_nsrs(nsr_id, now)
ro_nsr_public_key = db_ro_nsr["public_key"]
# check that action_id is not in the list of actions. Suffixed with :index
if action_id in db_ro_nsr["actions"]:
index = 1
while True:
new_action_id = "{}:{}".format(action_id, index)
if new_action_id not in db_ro_nsr["actions"]:
action_id = new_action_id
self.logger.debug(logging_text +
"Changing action_id in use to {}".
format(action_id))
break
index += 1
def _create_task(item,
action,
target_record,
target_record_id,
extra_dict=None):
nonlocal task_index
nonlocal action_id
nonlocal nsr_id
task = {
"action_id": action_id,
"nsr_id": nsr_id,
"task_id": "{}:{}".format(action_id, task_index),
"status": "SCHEDULED",
"action": action,
"item": item,
"target_record": target_record,
"target_record_id": target_record_id,
}
if extra_dict:
task.update(extra_dict) # params, find_params, depends_on
task_index += 1
return task
def _create_ro_task(vim_account_id,
item,
action,
target_record,
target_record_id,
extra_dict=None):
nonlocal action_id
nonlocal task_index
nonlocal now
_id = action_id + ":" + str(task_index)
db_ro_task = {
"_id":
_id,
"locked_by":
None,
"locked_at":
0.0,
"target_id":
"vim:" + vim_account_id,
"vim_info": {
"created": False,
"created_items": None,
"vim_id": None,
"vim_name": None,
"vim_status": None,
"vim_details": None,
"refresh_at": None,
},
"modified_at":
now,
"created_at":
now,
"to_check_at":
now,
"tasks": [
_create_task(item, action, target_record,
target_record_id, extra_dict)
],
}
return db_ro_task
def _process_image_params(target_image, vim_info):
find_params = {}
if target_image.get("image"):
find_params["filter_dict"] = {
"name": target_image.get("image")
}
if target_image.get("vim_image_id"):
find_params["filter_dict"] = {
"id": target_image.get("vim_image_id")
}
if target_image.get("image_checksum"):
find_params["filter_dict"] = {
"checksum": target_image.get("image_checksum")
}
return {"find_params": find_params}
def _process_flavor_params(target_flavor, vim_info):
def _get_resource_allocation_params(quota_descriptor):
"""
read the quota_descriptor from vnfd and fetch the resource allocation properties from the
descriptor object
:param quota_descriptor: cpu/mem/vif/disk-io quota descriptor
:return: quota params for limit, reserve, shares from the descriptor object
"""
quota = {}
if quota_descriptor.get("limit"):
quota["limit"] = int(quota_descriptor["limit"])
if quota_descriptor.get("reserve"):
quota["reserve"] = int(quota_descriptor["reserve"])
if quota_descriptor.get("shares"):
quota["shares"] = int(quota_descriptor["shares"])
return quota
flavor_data = {
"disk": int(target_flavor["storage-gb"]),
# "ram": max(int(target_flavor["memory-mb"]) // 1024, 1),
# ^ TODO manage at vim_connectors MB instead of GB
"ram": int(target_flavor["memory-mb"]),
"vcpus": target_flavor["vcpu-count"],
}
if target_flavor.get("guest-epa"):
extended = {}
numa = {}
epa_vcpu_set = False
if target_flavor["guest-epa"].get("numa-node-policy"):
numa_node_policy = target_flavor["guest-epa"].get(
"numa-node-policy")
if numa_node_policy.get("node"):
numa_node = numa_node_policy["node"][0]
if numa_node.get("num-cores"):
numa["cores"] = numa_node["num-cores"]
epa_vcpu_set = True
if numa_node.get("paired-threads"):
if numa_node["paired-threads"].get(
"num-paired-threads"):
numa["paired-threads"] = int(
numa_node["paired-threads"]
["num-paired-threads"])
epa_vcpu_set = True
if len(numa_node["paired-threads"].get(
"paired-thread-ids")):
numa["paired-threads-id"] = []
for pair in numa_node["paired-threads"][
"paired-thread-ids"]:
numa["paired-threads-id"].append(
(str(pair["thread-a"]),
str(pair["thread-b"])))
if numa_node.get("num-threads"):
numa["threads"] = int(numa_node["num-threads"])
epa_vcpu_set = True
if numa_node.get("memory-mb"):
numa["memory"] = max(
int(numa_node["memory-mb"] / 1024), 1)
if target_flavor["guest-epa"].get("mempage-size"):
extended["mempage-size"] = target_flavor[
"guest-epa"].get("mempage-size")
if target_flavor["guest-epa"].get(
"cpu-pinning-policy") and not epa_vcpu_set:
if target_flavor["guest-epa"][
"cpu-pinning-policy"] == "DEDICATED":
if target_flavor["guest-epa"].get("cpu-thread-pinning-policy") and \
target_flavor["guest-epa"]["cpu-thread-pinning-policy"] != "PREFER":
numa["cores"] = max(flavor_data["vcpus"], 1)
else:
numa["threads"] = max(flavor_data["vcpus"], 1)
epa_vcpu_set = True
if target_flavor["guest-epa"].get(
"cpu-quota") and not epa_vcpu_set:
cpuquota = _get_resource_allocation_params(
target_flavor["guest-epa"].get("cpu-quota"))
if cpuquota:
extended["cpu-quota"] = cpuquota
if target_flavor["guest-epa"].get("mem-quota"):
vduquota = _get_resource_allocation_params(
target_flavor["guest-epa"].get("mem-quota"))
if vduquota:
extended["mem-quota"] = vduquota
if target_flavor["guest-epa"].get("disk-io-quota"):
diskioquota = _get_resource_allocation_params(
target_flavor["guest-epa"].get("disk-io-quota"))
if diskioquota:
extended["disk-io-quota"] = diskioquota
if target_flavor["guest-epa"].get("vif-quota"):
vifquota = _get_resource_allocation_params(
target_flavor["guest-epa"].get("vif-quota"))
if vifquota:
extended["vif-quota"] = vifquota
if numa:
extended["numas"] = [numa]
if extended:
flavor_data["extended"] = extended
extra_dict = {"find_params": {"flavor_data": flavor_data}}
flavor_data_name = flavor_data.copy()
flavor_data_name["name"] = target_flavor["name"]
extra_dict["params"] = {"flavor_data": flavor_data_name}
return extra_dict
def _process_net_params(target_vld, vim_info):
nonlocal indata
extra_dict = {}
if vim_info.get("vim_network_name"):
extra_dict["find_params"] = {
"filter_dict": {
"name": vim_info.get("vim_network_name")
}
}
elif vim_info.get("vim_network_id"):
extra_dict["find_params"] = {
"filter_dict": {
"id": vim_info.get("vim_network_id")
}
}
elif target_vld.get("mgmt-network"):
extra_dict["find_params"] = {
"mgmt": True,
"name": target_vld["id"]
}
else:
# create
extra_dict["params"] = {
"net_name":
"{}-{}".format(
indata["name"][:16],
target_vld.get("name", target_vld["id"])[:16]),
"ip_profile":
vim_info.get('ip_profile'),
"provider_network_profile":
vim_info.get('provider_network'),
}
if not target_vld.get("underlay"):
extra_dict["params"]["net_type"] = "bridge"
else:
extra_dict["params"][
"net_type"] = "ptp" if target_vld.get(
"type") == "ELINE" else "data"
return extra_dict
def _process_vdu_params(target_vdu, vim_info):
nonlocal vnfr_id
nonlocal nsr_id
nonlocal indata
nonlocal vnfr
nonlocal vdu2cloud_init
vnf_preffix = "vnfrs:{}".format(vnfr_id)
ns_preffix = "nsrs:{}".format(nsr_id)
image_text = ns_preffix + ":image." + target_vdu["ns-image-id"]
flavor_text = ns_preffix + ":flavor." + target_vdu[
"ns-flavor-id"]
extra_dict = {"depends_on": [image_text, flavor_text]}
net_list = []
for iface_index, interface in enumerate(
target_vdu["interfaces"]):
if interface.get("ns-vld-id"):
net_text = ns_preffix + ":vld." + interface["ns-vld-id"]
else:
net_text = vnf_preffix + ":vld." + interface[
"vnf-vld-id"]
extra_dict["depends_on"].append(net_text)
net_item = {
"name": interface["name"],
"net_id": "TASK-" + net_text,
"vpci": interface.get("vpci"),
"type": "virtual",
# TODO mac_address: used for SR-IOV ifaces #TODO for other types
# TODO floating_ip: True/False (or it can be None)
}
if interface.get("type") in ("SR-IOV", "PCI-PASSTHROUGH"):
net_item["use"] = "data"
net_item["model"] = interface["type"]
net_item["type"] = interface["type"]
elif interface.get("type") == "OM-MGMT" or interface.get("mgmt-interface") or \
interface.get("mgmt-vnf"):
net_item["use"] = "mgmt"
else: # if interface.get("type") in ("VIRTIO", "E1000", "PARAVIRT"):
net_item["use"] = "bridge"
net_item["model"] = interface.get("type")
net_list.append(net_item)
if interface.get("mgmt-vnf"):
extra_dict["mgmt_vnf_interface"] = iface_index
elif interface.get("mgmt-interface"):
extra_dict["mgmt_vdu_interface"] = iface_index
# cloud config
cloud_config = {}
if target_vdu.get("cloud-init"):
if target_vdu["cloud-init"] not in vdu2cloud_init:
vdu2cloud_init[
target_vdu["cloud-init"]] = self._get_cloud_init(
target_vdu["cloud-init"])
cloud_content_ = vdu2cloud_init[target_vdu["cloud-init"]]
cloud_config["user-data"] = self._parse_jinja2(
cloud_content_, target_vdu.get("additionalParams"),
target_vdu["cloud-init"])
if target_vdu.get("boot-data-drive"):
cloud_config["boot-data-drive"] = target_vdu.get(
"boot-data-drive")
ssh_keys = []
if target_vdu.get("ssh-keys"):
ssh_keys += target_vdu.get("ssh-keys")
if target_vdu.get("ssh-access-required"):
ssh_keys.append(ro_nsr_public_key)
if ssh_keys:
cloud_config["key-pairs"] = ssh_keys
extra_dict["params"] = {
"name":
"{}-{}-{}-{}".format(indata["name"][:16],
vnfr["member-vnf-index-ref"][:16],
target_vdu["vdu-name"][:32],
target_vdu.get("count-index") or 0),
"description":
target_vdu["vdu-name"],
"start":
True,
"image_id":
"TASK-" + image_text,
"flavor_id":
"TASK-" + flavor_text,
"net_list":
net_list,
"cloud_config":
cloud_config or None,
"disk_list":
None, # TODO
"availability_zone_index":
None, # TODO
"availability_zone_list":
None, # TODO
}
return extra_dict
def _process_items(target_list, existing_list, db_record,
db_update, db_path, item, process_params):
nonlocal db_ro_tasks
nonlocal db_new_tasks
nonlocal task_index
# ensure all the target_list elements has an "id". If not assign the index
for target_index, tl in enumerate(target_list):
if tl and not tl.get("id"):
tl["id"] = str(target_index)
# step 1 networks to be deleted/updated
for vld_index, existing_vld in enumerate(existing_list):
target_vld = next((vld for vld in target_list
if vld["id"] == existing_vld["id"]),
None)
for existing_vim_index, existing_vim_info in enumerate(
existing_vld.get("vim_info", ())):
if not existing_vim_info:
continue
if target_vld:
target_viminfo = next(
(target_viminfo
for target_viminfo in target_vld.get(
"vim_info", ())
if existing_vim_info["vim_account_id"] ==
target_viminfo["vim_account_id"]), None)
else:
target_viminfo = None
if not target_viminfo:
# must be deleted
self._assign_vim(
existing_vim_info["vim_account_id"])
db_new_tasks.append(
_create_task(
item,
"DELETE",
target_record="{}.{}.vim_info.{}".format(
db_record, vld_index,
existing_vim_index),
target_record_id="{}.{}".format(
db_record, existing_vld["id"])))
# TODO delete
# TODO check one by one the vims to be created/deleted
# step 2 networks to be created
for target_vld in target_list:
vld_index = -1
for vld_index, existing_vld in enumerate(existing_list):
if existing_vld["id"] == target_vld["id"]:
break
else:
vld_index += 1
db_update[db_path +
".{}".format(vld_index)] = target_vld
existing_list.append(target_vld)
existing_vld = None
for vim_index, vim_info in enumerate(
target_vld["vim_info"]):
existing_viminfo = None
if existing_vld:
existing_viminfo = next(
(existing_viminfo
for existing_viminfo in existing_vld.get(
"vim_info", ())
if vim_info["vim_account_id"] ==
existing_viminfo["vim_account_id"]), None)
# TODO check if different. Delete and create???
# TODO delete if not exist
if existing_viminfo:
continue
extra_dict = process_params(target_vld, vim_info)
self._assign_vim(vim_info["vim_account_id"])
db_ro_tasks.append(
_create_ro_task(
vim_info["vim_account_id"],
item,
"CREATE",
target_record="{}.{}.vim_info.{}".format(
db_record, vld_index, vim_index),
target_record_id="{}.{}".format(
db_record, target_vld["id"]),
extra_dict=extra_dict))
db_update[db_path +
".{}".format(vld_index)] = target_vld
def _process_action(indata):
nonlocal db_ro_tasks
nonlocal db_new_tasks
nonlocal task_index
nonlocal db_vnfrs
nonlocal db_ro_nsr
if indata["action"] == "inject_ssh_key":
key = indata.get("key")
user = indata.get("user")
password = indata.get("password")
for vnf in indata.get("vnf", ()):
if vnf.get("_id") not in db_vnfrs:
raise NsException("Invalid vnf={}".format(
vnf["_id"]))
db_vnfr = db_vnfrs[vnf["_id"]]
for target_vdu in vnf.get("vdur", ()):
vdu_index, vdur = next(
(i_v for i_v in enumerate(db_vnfr["vdur"])
if i_v[1]["id"] == target_vdu["id"]),
(None, None))
if not vdur:
raise NsException(
"Invalid vdu vnf={}.{}".format(
vnf["_id"], target_vdu["id"]))
vim_info = vdur["vim_info"][0]
self._assign_vim(vim_info["vim_account_id"])
target_record = "vnfrs:{}:vdur.{}.ssh_keys".format(
vnf["_id"], vdu_index)
extra_dict = {
"depends_on": [
"vnfrs:{}:vdur.{}".format(
vnf["_id"], vdur["id"])
],
"params": {
"ip_address":
vdur.gt("ip_address"),
"user":
user,
"key":
key,
"password":
password,
"private_key":
db_ro_nsr["private_key"],
"salt":
db_ro_nsr["_id"],
"schema_version":
db_ro_nsr["_admin"]["schema_version"]
}
}
db_ro_tasks.append(
_create_ro_task(vim_info["vim_account_id"],
"vdu",
"EXEC",
target_record=target_record,
target_record_id=None,
extra_dict=extra_dict))
with self.write_lock:
if indata.get("action"):
_process_action(indata)
else:
# compute network differences
# NS.vld
step = "process NS VLDs"
_process_items(target_list=indata["ns"]["vld"] or [],
existing_list=db_nsr.get("vld") or [],
db_record="nsrs:{}:vld".format(nsr_id),
db_update=db_nsr_update,
db_path="vld",
item="net",
process_params=_process_net_params)
step = "process NS images"
_process_items(target_list=indata["image"] or [],
existing_list=db_nsr.get("image") or [],
db_record="nsrs:{}:image".format(nsr_id),
db_update=db_nsr_update,
db_path="image",
item="image",
process_params=_process_image_params)
step = "process NS flavors"
_process_items(target_list=indata["flavor"] or [],
existing_list=db_nsr.get("flavor") or [],
db_record="nsrs:{}:flavor".format(nsr_id),
db_update=db_nsr_update,
db_path="flavor",
item="flavor",
process_params=_process_flavor_params)
# VNF.vld
for vnfr_id, vnfr in db_vnfrs.items():
# vnfr_id need to be set as global variable for among others nested method _process_vdu_params
step = "process VNF={} VLDs".format(vnfr_id)
target_vnf = next((vnf
for vnf in indata.get("vnf", ())
if vnf["_id"] == vnfr_id), None)
target_list = target_vnf.get(
"vld") if target_vnf else None
_process_items(
target_list=target_list or [],
existing_list=vnfr.get("vld") or [],
db_record="vnfrs:{}:vld".format(vnfr_id),
db_update=db_vnfrs_update[vnfr["_id"]],
db_path="vld",
item="net",
process_params=_process_net_params)
target_list = target_vnf.get(
"vdur") if target_vnf else None
step = "process VNF={} VDUs".format(vnfr_id)
_process_items(
target_list=target_list or [],
existing_list=vnfr.get("vdur") or [],
db_record="vnfrs:{}:vdur".format(vnfr_id),
db_update=db_vnfrs_update[vnfr["_id"]],
db_path="vdur",
item="vdu",
process_params=_process_vdu_params)
step = "Updating database, Creating ro_tasks"
if db_ro_tasks:
self.db.create_list("ro_tasks", db_ro_tasks)
step = "Updating database, Appending tasks to ro_tasks"
for task in db_new_tasks:
if not self.db.set_one("ro_tasks",
q_filter={
"tasks.target_record":
task["target_record"]
},
update_dict={
"to_check_at": now,
"modified_at": now
},
push={"tasks": task},
fail_on_empty=False):
self.logger.error(
logging_text +
"Cannot find task for target_record={}".format(
task["target_record"]))
# TODO something else appart from logging?
step = "Updating database, nsrs"
if db_nsr_update:
self.db.set_one("nsrs", {"_id": nsr_id}, db_nsr_update)
for vnfr_id, db_vnfr_update in db_vnfrs_update.items():
if db_vnfr_update:
step = "Updating database, vnfrs={}".format(vnfr_id)
self.db.set_one("vnfrs", {"_id": vnfr_id},
db_vnfr_update)
self.logger.debug(logging_text + "Exit")
return {
"status": "ok",
"nsr_id": nsr_id,
"action_id": action_id
}, action_id, True
except Exception as e:
if isinstance(e, (DbException, NsException)):
self.logger.error(
logging_text +
"Exit Exception while '{}': {}".format(step, e))
else:
e = traceback_format_exc()
self.logger.critical(
logging_text +
"Exit Exception while '{}': {}".format(step, e),
exc_info=True)
raise NsException(e)
def complete_task(self, worker, prio=None):
query = worker[0]
args = worker[1]
callback = worker[2]
data_pack = worker[3]
get_info = worker[4]
query_type = worker[5]
try:
if get_info:
get_info['time'] = timestamp() - get_info['time']
if args:
self.cursor.execute(query, args)
else:
self.cursor.execute(query)
if query_type == 0:
if get_info:
if callback:
if data_pack:
callback(data_pack, get_info)
else:
callback(get_info)
else:
if callback:
if data_pack:
callback(data_pack)
else:
callback()
if query_type == 1:
data = self.cursor.fetchone()
if get_info:
if callback:
if data_pack:
callback(data, data_pack, get_info)
else:
callback(data, get_info)
else:
if callback:
if data_pack:
callback(data, data_pack)
else:
callback(data)
if query_type == 2:
data = self.cursor.fetchall()
if get_info:
if callback:
if data_pack:
callback(data, data_pack, get_info)
else:
callback(data, get_info)
else:
if callback:
if data_pack:
callback(data, data_pack)
else:
callback(data)
if prio:
self._p_queue.task_done()
else:
self._r_queue.task_done()
except Exception as SQL_ERROR:
# Possible errors
class_error, actual_error, traceback = exc_info()
format_error = '-' * 64 + '\nExceptions probable cause (SQL Query: {0})\n{1}\nActual Error:\n{2}'.format(
query, class_error, SQL_ERROR)
if self.error_handling == 'print':
print(format_error)
print('-' * 64)
else:
echo_console(format_error)
echo_console('-' * 64)
logging_error(traceback_format_exc())
async def on_message(message):
command = 'bracket' # Pre-setting the variable for use in the try/except block below (L78)
# If the bot is the user, do not respond
if message.author == client.user:
return
# If the bot is mentioned in a message, respond with a message informing it of being a bot
if client.user.mentioned_in(message):
# If @everyone or @here is used, ignore
if "@everyone" in message.content or "@here" in message.content:
return
# Choose from a random response, then follow with a Bot message
responses = ["Ok", "Thanks", "Sounds good to me", "Buff Rashid", "Buff Rashid", "Beep Boop", "Yes", "No", "Good to know", "Glad to hear it", "I'll keep that in mind", "The answer lies in the heart of battle", "Go home and be a family man"]
await message.channel.send("{0} \n**I am a Bot that plays Rashid. Mentions cause my little Rashid brain to short circuit. Did you have ~~an eagle spi~~ a command?**".format(random_choice(responses)))
return
try:
# Check if the channel is in the DB
# Add it if it isn't
if not settings_exist(message.guild.id, message.channel.id):
raise Exception("Lizard-BOT failed to create DB entry for: " + message.guild.name + ". Guild ID: " + message.guild.id)
# Get prefix for the guild
prefix = read_db('guild', 'prefix-lizard', message.guild.id)
# Check if the attempted_cmd is !prefix-lizard and has too many args
if (message.content.split(' ')[0] == "!prefix-lizard" or message.content.split(' ')[0] == "!prefliz") and len(message.content.split()) > 1:
await message.channel.send("Too many arguments. Check help-lizard for more info")
return
# Hardcode prefix command to be accessible via !
elif message.content.split(' ')[0] == "!prefix-lizard" or message.content.split(' ')[0] == "!prefliz":
response = await client.interface.call_command('prefix-lizard', 0, 0, 0, guild=message.guild.id)
if response:
await message.channel.send(response)
return
# If other commands don't start with the correct prefix, do nothing
elif not message.content.startswith(prefix):
return
# Check if the attempted_cmd takes arguments
elif message.content.split(' ')[0][1:].lower() in client.no_arg_cmds and len(message.content.split()) > 1:
await message.channel.send("Too many arguments. Check help-lizard for more info")
return
# Rotate through commands to see if the message matches
for command in client.commands:
command = command.lower() # Lower the command for easier matching
msg = message.content # The message
attempted_cmd = msg.split(' ')[0][1:].lower() # Get the attempted command from the beginning of the string
if attempted_cmd in ['challonge', 'chal', 'edit'] and len(msg.split(' ')) > 1:
attempted_cmd += ' ' + msg.split(' ')[1].lower()
# Check if the message begins with a command
if attempted_cmd and attempted_cmd == command:
user = message.author # The author
kwargs = {'guild':message.guild.id}
# Remove the command from the start
msg = msg[len(command)+1:].strip()
# Check command to see if we need keyword args
if command in ['challonge checkin', 'chal checkin']:
kwargs['guild_members'] = message.guild.members
elif command in ['edit botrole', 'edit role']:
kwargs['guild_default_role'] = message.guild.default_role
kwargs['role_mentions'] = message.role_mentions
elif command in ['edit bracket', 'edit pingtest', 'edit status', 'edit seeding', 'edit stream', 'edit tos']:
kwargs['channel_mentions'] = message.channel_mentions
if command in ['edit tos']:
kwargs['mentions'] = message.mentions
elif command in ['draw']:
kwargs['full_msg'] = message
kwargs['client'] = client
# Await the interface calling the command
response = await client.interface.call_command(command, msg, user, message.channel, **kwargs)
# If there is a response, send it
if response:
await message.channel.send(response)
break
except Exception:
string_info = str(sys_exc_info()[1]) # Error message
function_name = string_info.split(':')[0] # The command the error message came from
# Expected error
# Return friendly user message
# Additional checks needed for challonge and edit commands that have multiple subcommands
if client.interface._func_mapping[command].__name__ in function_name.strip("*").lower() or ('challonge' in client.interface._func_mapping[command].__name__ and 'challonge' in function_name.strip("*").lower()) or ('edit' in client.interface._func_mapping[command].__name__ and 'edit' in function_name.strip("*").lower()):
await message.channel.send(function_name.replace('_', '-') + ': ' + ':'.join(string_info.split(':')[1:]))
elif command == 'dev':
# Return user message
await message.channel.send(escape_markdown(traceback_format_exc()))
# Print error to console
traceback_print_exc()
else:
# Print error to console
traceback_print_exc()
# If we get this far and something breaks
# Something is very wrong. Send user generic error message
await message.channel.send("I is broken.\nBuff Rashid and submit an issue via <https://github.com/lizardman301/Lizard-bot-rsf/issues>\nOr just tell Lizardman301. That's what I do.")
