def erase_card(id, DB: MySQL, EEM: EEM):
DB.start_transaction()
if get_card(id, DB, EEM)["status"] == "eeio":
DB.start_transaction()
status, message = DB.delete_query_simple(__table_hardware, "id", id)
else:
status, message = DB.delete_query_simple(__table_net, "id", id)
# First status code checks:
# 1: Syntaxis
# 2: Completeness
if status:
status, result = DB.commit_transaction()
# Second status checks:
# 1: Data integrity
if status:
return messenger.message200("OK")
# Implicit rollback
else:
return messenger.message404(message)
else:
status, error = DB.rollback(messsage)
return messenger.message404(error)
def modify_hardware_tag(card, DB: MySQL, EEM: EEM):
DB.start_transaction()
status, message = modify_card(card, __table_hardware, hardware_card_keys,
DB, EEM)
status, message = modify_capacities(card, __table_hardware_capacity,
hardware_capacity_keys, DB, EEM)
# First status code checks:
# 1: Syntaxis
# 2: Completeness
if status:
status, message = DB.commit_transaction()
# Second status checks:
# 1: Data integrity
if status:
return messenger.message200("OK")
# Implicit rollback
else:
return messenger.message404(message)
else:
status, error = DB.rollback(message)
return messenger.message404(error)
def get_all_cards(DB: MySQL, EEM: EEM):
out = EEM.get_list()
ids = re.findall('0x[\w]*', out)
if ids:
return ids
else:
return messenger.message404("There is not card info avilable")
def get_workload(id, DB: MySQL):
statement = ("SELECT * FROM %s ") % __table_workloads
statement += ("WHERE ID = %s") % id
workload = DB.select_query(statement)
if workload and isinstance(workload, Iterable):
return process_workload(DB, next(iter(workload)))
else:
error = "The requested ID does not exist on the server"
return messenger.message404(error)
def get_all_workloads(DB: MySQL):
statement = ("SELECT * FROM ") + __table_workloads
workloads = DB.select_query(statement)
res_workloads = []
if workloads:
for workload in workloads:
res_workloads.append(process_workload(DB, workload))
return res_workloads
else:
error = "The requested ID does not exist on the server"
return messenger.message404(error)
def erase_workload(id, DB: MySQL):
DB.start_transaction()
# A single delete is enough as child tables delete on cascade
status, message = DB.delete_query_simple(__table_workloads, "id", id)
# First status code checks:
# 1: Syntaxis
# 2: Completeness
if status:
status, message = DB.commit_transaction()
# Second status checks:
# 1: Data integrity
if status:
return messenger.message200("OK")
# Implicit rollback
else:
return messenger.message404(message)
else:
status, error = DB.rollback(messsage)
return messenger.message404(error)
def get_all_assignments(DB: MySQL):
statement = ("SELECT * FROM %s ") % __table
assignments = DB.select_query(statement)
res_assignments = []
if assignments:
for assignment in assignments:
res_assignment = {}
for x in range(0, len(assignment_keys)):
res_assignment[assignment_keys[x]] = assignment[x]
res_assignments.append(res_assignment)
return res_assignments
else:
return messenger.message404("No assignments found")
def get_card(id, DB: MySQL, EEM: EEM):
ids = get_all_cards(DB, EEM)
if id not in ids:
return messenger.message404(
"The requested card ID does not exist on the server")
out = eemParser.parse(EEM.get_box_info(id))
if out["status"] == "eeio":
table = __table_hardware
mapping = hardware_card_keys
statement = ("SELECT * FROM %s "
'WHERE hardware_id = "%s"') % (__table_hardware_capacity,
id)
capacities = DB.select_query(statement)
else:
table = __table_net
mapping = net_card_keys
capacities = None
statement = ("SELECT * FROM %s " 'WHERE id = "%s"') % (table, id)
card = DB.select_query(statement)
if card:
if (isinstance(card, Iterable) and not isinstance(card, str)):
card = next(iter(card))
for param in range(0, len(mapping)):
out[mapping[param]] = card[param]
else:
for param in range(0, len(mapping)):
if mapping[param] != "id":
out[mapping[param]] = "UNKNOWN"
if capacities:
insert_capactities = []
for capacity in capacities:
insert_capacity = {}
for param in range(0, len(hardware_capacity_keys)):
if hardware_capacity_keys[param] != "hardware_id":
insert_capacity[hardware_capacity_keys[param]] \
= capacity[param]
insert_capactities.append(insert_capacity)
out["capacity"] = insert_capactities
else:
out["capacity"] = "UNKNOWN"
return out
def get_state(DB: MySQL, EEM: EEM):
n_cards = 0
cards = []
for line in EEM.get_all_logical_assigned().splitlines():
if "[Errno 113]" in line:
return messenger.message404("No route to EEM")
if (
line != "----------------------------------------" and
"timestamp:" not in line
):
if len(cards) <= n_cards:
cards.append("")
cards[n_cards] += line + '\n'
else:
n_cards += 1
status, message = update_cards(cards, DB)
status, message = update_assigned_cards(cards, DB)
if not status:
return messenger.general_error(message)
return make_response(create_state_html(DB, EEM))
def create_workload(workload, DB: MySQL):
DB.start_transaction()
mapping = deepcopy(workload_keys)
mapping_requirement = deepcopy(hardware_requirements_keys)
mapping_requirement_insert = deepcopy(hardware_requirements_keys)
mapping_capacity = deepcopy(capacity_requirements_keys)
mapping.remove("id") # As it is assigned by the API
mapping_requirement.remove("workload_id") # Not present in the petition
mapping_requirement.remove("requirement_id") # Not present in the petition
mapping_requirement_insert.remove(
"requirement_id") # Not present in the petition
mapping_capacity.remove("workload_id") # Not present in the petition
mapping_capacity.remove("requirement_id") # Not present in the petition
if len(workload.keys()) - 1 != len(mapping):
message = "Inserted workload data is incorrect"
return messenger.message404(message)
# Get the assigned ID of the workload
statement = ("SELECT MAX(id) FROM workloads")
workload_id = DB.select_query(statement)
while (isinstance(workload_id, Iterable)):
workload_id = next(iter(workload_id))
if not workload_id or workload_id < 0:
workload_id = 1
else:
workload_id += 1
values = [workload_id]
for x in range(0, len(mapping)):
if mapping[x] in workload:
values.append(workload[mapping[x]])
else:
message = "%s not introduced in the request" % (mapping[x])
return messenger.message404(message)
status1, message1 = DB.insert_query(__table_workloads, workload_keys,
values)
# Time to create the requirements of the workload, one entry each
requirements = workload["requirements"]
req_number = 0
for requirement in requirements:
req_number += 1
statement = ("SELECT MAX(requirement_id) FROM hardware_requirements")
req_id = DB.select_query(statement)
while (isinstance(req_id, Iterable)):
req_id = next(iter(req_id))
if not req_id:
req_id = req_number
else:
req_id += req_number
values = [req_id, workload_id]
for x in range(0, len(mapping_requirement)):
if mapping_requirement[x] in requirement:
values.append(requirement[mapping_requirement[x]])
else:
message = "%s not introduced in the request" % (
mapping_requirement[x])
return messenger.message404(message)
status2, message2 = DB.insert_query(__table_hardware_requirements,
hardware_requirements_keys, values)
capacity_req = requirement["hardware_capacity_requirements"]
for capacity in capacity_req:
values = [workload_id, req_id]
for x in range(0, len(mapping_capacity)):
if mapping_capacity[x] in capacity:
values.append(capacity[mapping_capacity[x]])
else:
message = "%s not introduced in the request" % (
mapping_capacity[x])
return messenger.message404(message)
status3, message3 = DB.insert_query(__table_capacity_requirements,
capacity_requirements_keys,
values)
if not status1:
status = False
message = message1
elif not status2:
status = False
message = message2
elif not status3:
status = False
message = message3
else:
status = True
message = "OK"
# First status code checks:
# 1: Syntaxis
# 2: Completeness
if status:
status, message = DB.commit_transaction()
# Second status checks:
# 1: Data integrity
if status:
return messenger.messageWorkload(workload_id)
# Implicit rollback
else:
return messenger.message404(message)
else:
status, error = DB.rollback(message)
return messenger.message404(error)
