def get(self, uuid, page):
try:
rows_uuid = TokensModel.find_by_uuid(uuid, "device_store")
except:
return {"message": "Data search operation failed!"}, 500
if not rows_uuid:
return {'message': "Request with UUID: '{}' doesn't exists.".format(uuid)}, 404
config.NO_OF_DEVICES = len(rows_uuid)
config.NO_OF_PAGES = ceil(config.NO_OF_DEVICES/10)
print("Pagination: UUID for this request is:", uuid)
print("Pagination: Total number of pages:", config.NO_OF_PAGES)
print("Pagination: Page number requested is:", page)
if page < 1 or page > config.NO_OF_PAGES:
return {'message': "Page doesn't exists!"}, 400
try:
rows = TokensModel.find_by_uuid_slice(uuid, page, "device_store")
except:
return {"message": "Data search operation failed!"}, 500
devices = []
for row in rows:
devices.append({'ipaddr': row[1], 'username': row[2], 'password': row[3], 'sa_name': row[4],
'va_name': row[5], 'domain': row[6]})
print("==>> Printing devices from within get method for resource: Tokens <<==")
print(devices)
if rows:
return {'uuid': uuid,
'totalpages': config.NO_OF_PAGES,
'devices': devices}
return {"message": "Request with UUID: '{}' not found!".format(uuid)}, 404
def send_request_cssm(self, uuid, oauthToken):
print(
"-------------------------------------------------------------------------------------------"
)
print("contact cssm debugs")
print(
"-------------------------------------------------------------------------------------------"
)
threads = []
slr_table = slr_req_tbl
try:
rows = TokensModel.find_by_uuid(uuid, "device_store")
except Exception as e:
print(e)
return database_err, 500
if not rows:
return ({"request": "No Devices with this UUID"}), 400
for row in rows:
print("Launching threads to get auth tokens")
response_update = {}
response_update['status'] = resp_status_started
TokensModel.update(uuid, response_update, "upload_info_store")
self.slr.update_status(slr_table, row[0], row[1], s_start, step)
th = threading.Thread(target=slrcontactcssm.get_cssm_response,
args=(row[6], row[5], oauthToken, row[1],
row[0]))
th.start()
threads.append(th)
return (accept), 201
def send_authorize_information(cls, device_ip, username, password, cli,
authz_info, tftp_server, tftp_loc, uuid):
s = slr("", "", "")
client = tftpy.TftpClient(tftp_server, 69)
file_name = device_ip + secrets.token_hex(5) + extension
dest_file = dest_dir + file_name
try:
f = open(dest_file, "w+")
print(authz_info)
f.write(authz_info)
f.close()
client.upload(tftp_loc + file_name, dest_file)
cli.append("lic smart reservation install file tftp://" +
tftp_server + "/" + tftp_loc + file_name)
print(cli)
slrauthzswitch.config_commands(device_ip, username, password, cli)
s.update_status(slr_req_tbl, uuid, device_ip, s_done, step)
except Exception as e:
print(e)
s.update_status(slr_req_tbl, uuid, device_ip,
str(e).split(":")[0], step)
rows = s.find_by_step_status(slr_req_tbl, uuid, s_start, step)
if (len(rows) == 0):
response_update = {}
response_update['status'] = resp_status_complete
TokensModel.update(uuid, response_update, "upload_info_store")
del (s)
def get(self, uuid):
threads = []
logger.info(uuid)
try:
rows = TokensModel.find_by_uuid(uuid, "device_store")
except Exception as e:
print(e)
logger.error({"message": "Data search operation failed!"},
exc_info=True)
return {"message": "Data search operation failed!"}, 500
for row in rows:
logger.info("Launching threads to get auth tokens")
# Updating the response status Step 2 started
response_update = {'status': "S2s"}
TokensModel.update(uuid, response_update, "upload_info_store")
self.slr.update_status(SLR_REQUEST_CODE_TABLE_NAME, row[0], row[1],
"Started", "step1")
th = threading.Thread(target=SlrRequestCode.execute_cli_wrapper,
args=(row[1], row[2], row[3],
req_token_command, row[0], row[4],
row[5], row[6]))
th.start()
threads.append(th)
logger.info({"request": "accepted"})
return {"request": "accepted"}, 201
def process_request(self, uuid):
threads = []
slr_table = slr_req_tbl
try:
rows = TokensModel.find_by_uuid(uuid, "device_store")
except Exception as e:
print(e)
return database_err, 500
for row in rows:
response_update = {}
response_update['status'] = resp_status_started
TokensModel.update(uuid, response_update, "upload_info_store")
self.slr.update_status(slr_table, row[0], row[1], s_start, step)
print(row)
val = self.slr.find_by_uuid_ipaddr(uuid, slr_table, row[1])
print(val)
if val[0][3] == s_done:
th = threading.Thread(
target=slrauthzswitch.send_authorize_information,
args=(row[1], row[2], row[3], req_token_command, val[0][6],
val[0][9], val[0][10], uuid))
th.start()
threads.append(th)
else:
self.slr.update_status(slr_table, uuid, row[1],
"Error in previous step", step)
rows = self.slr.find_by_step_status(slr_req_tbl, uuid, s_start,
step)
if (len(rows) == 0):
response_update = {}
response_update['status'] = resp_status_complete
TokensModel.update(uuid, response_update,
"upload_info_store")
return accept, 201
def generate_output(self, uuid, page):
slr_table = SLR_REQUEST_CODE_TABLE_NAME
response = {}
try:
total_rows = TokensModel.find_by_uuid(uuid, "device_store")
except Exception as e:
print(e)
logger.error({"message": "Data search operation failed!"},
exc_info=True)
return {"message": "Data search operation failed!"}, 500
config.NO_OF_DEVICES = len(total_rows)
config.NO_OF_PAGES = ceil(config.NO_OF_DEVICES /
NUMBER_OF_DEVICES_PER_PAGE)
response["totalpages"] = config.NO_OF_PAGES
response["devices"] = []
try:
rows = TokensModel.find_by_uuid_slice(uuid, page, "device_store")
except Exception as e:
print(e)
logger.error({"message": "Data search operation failed!"},
exc_info=True)
return {"message": "Data search operation failed!"}, 500
for row in rows:
ip_address = row[1]
try:
val = self.slr.find_by_uuid_ipaddr(uuid, slr_table, ip_address)
except Exception as e:
print(e)
logger.error({"message": "Data search operation failed!"},
exc_info=True)
return {"message": "Data search operation failed!"}, 500
device_dict = {}
for i in col:
device_dict[col[i]] = row[i]
logger.info(val)
device_dict['s2Status'] = ""
device_dict['s3Status'] = ""
device_dict['s4Status'] = ""
try:
device_dict['s2Status'] = val[0][2]
device_dict['s3Status'] = val[0][3]
device_dict['s4Status'] = val[0][4]
except Exception as e:
print(e)
response["devices"].append(device_dict)
del device_dict
logger.info("Final response")
logger.info(response)
return response, 201
def generate_output(self, uuid, page):
slr_table = None
slr_table = slr_req_tbl
if (slr_table == None):
return invalid_request, 404
response = {}
try:
total_rows = TokensModel.find_by_uuid(uuid, "device_store")
except Exception as e:
print(e)
return database_err, 500
config.NO_OF_DEVICES = len(total_rows)
config.NO_OF_PAGES = ceil(config.NO_OF_DEVICES /
num_of_device_per_page)
response[pages] = config.NO_OF_PAGES
response[device] = []
try:
rows = TokensModel.find_by_uuid_slice(uuid, page, "device_store")
except Exception as e:
print(e)
return database_err, 500
for row in rows:
ip_address = row[ip_addr]
try:
val = self.slr.find_by_uuid_ipaddr(uuid, slr_table, ip_address)
except Exception as e:
print(e)
return database_err, 500
device_dict = {}
for i in col:
device_dict[col[i]] = row[i]
print(val)
device_dict['s2Status'] = ""
device_dict['s3Status'] = ""
device_dict['s4Status'] = ""
try:
device_dict['s2Status'] = val[0][2]
device_dict['s3Status'] = val[0][3]
device_dict['s4Status'] = val[0][4]
except Exception as e:
print(e)
response[device].append(device_dict)
del (device_dict)
print("Final response")
print(response)
return (response), 201
def send_authorize_information(cls, device_ip, username, password, cli,
authz_info, tftp_server, tftp_loc, uuid):
s = slr("", "", "")
try:
logger.info(
"Trying to connect to tftp server:{}".format(tftp_server))
client = tftpy.TftpClient(tftp_server, 69)
file_name = device_ip + ".txt"
dest_file = dest_dir + file_name
try:
f = open(dest_file, "w+")
logger.info(authz_info)
f.write(authz_info)
f.close()
logger.info("Trying to upload file:{}".format(file_name))
client.upload(file_name, dest_file)
cli.append("lic smart reservation install file tftp://" +
tftp_server + "/" + file_name)
logger.info(cli)
SlrAuthSwitch.config_commands(device_ip, username, password,
cli)
#if dlc_status_rows is not empty means dlc is performed
dlc_status_rows = TokensModel.get_dlc_status(uuid, device_ip)
if dlc_status_rows:
dlc_status = dlc_status_rows[0][2]
if dlc_status == "dlc_convert_success":
s.update_status(SLR_REQUEST_CODE_TABLE_NAME, uuid,
device_ip, "DLC Success and Completed",
"step3")
else:
s.update_status(SLR_REQUEST_CODE_TABLE_NAME, uuid,
device_ip,
"DLC Failed and SLR Successful",
"step3")
else:
s.update_status(SLR_REQUEST_CODE_TABLE_NAME, uuid,
device_ip, "Completed", "step3")
except Exception as e:
print("file upload failed:", e)
logger.info("Failed uploading file:{}".format(file_name))
s.update_status(SLR_REQUEST_CODE_TABLE_NAME, uuid, device_ip,
str(e).split(":")[0], "step3")
except Exception as e:
logger.info(
"Failure connecting to tftp server:{}".format(tftp_server))
print("Connection to tftp server failed:", e)
rows = s.find_by_step_status(SLR_REQUEST_CODE_TABLE_NAME, uuid,
"Started", "step3")
if len(rows) == 0:
# Updating the response status to Step 4 completed
response_update = {'status': "S4c"}
TokensModel.update(uuid, response_update, "upload_info_store")
del s
def get(self):
# Return last 10 registration requests executed
print("In class registrations - User ID:", config.USER_ID)
try:
rows = TokensModel.find_last_records(config.USER_ID,
"upload_info_store",
"timestamp")
except:
return {"message": "Data search operation failed!"}, 500
devices = []
for row in rows:
devices.append({
'uuid': row[0],
'filename': row[2],
'registration_type': row[3],
'timestamp': row[4],
'status': row[5]
})
print(
"==>> Printing devices from within get method for resource: Tokens <<=="
)
print(devices)
if rows:
return {'message': 'Last registrations', 'devices': devices}
return {"message": "Request for last 10 registrations not found!"}, 404
def get(self, uuid, page):
data = File.parser.parse_args()
print("OAuth token is:", data['oauth_token'])
if page < 1 or page > config.NO_OF_PAGES:
return {'message': "Page doesn't exists!"}, 400
try:
rows = TokensModel.find_by_uuid_slice(uuid, "device_store", page)
except:
return {"message": "Data search operation failed!"}, 500
devices = []
for row in rows:
devices.append({
'ipaddr': row[1],
'username': row[2],
'password': row[3],
'sa_name': row[4],
'va_name': row[5],
'domain': row[6]
})
print(
"==>> Printing devices from within get method for resource: Tokens <<=="
)
print(devices)
if rows:
return {'uuid': uuid, 'devices': devices}
return {
"message": "Request with UUID: '{}' not found!".format(uuid)
}, 404
def get(self, uuid):
try:
rows = TokensModel.find_by_uuid(uuid, "upload_info_store")
except Exception as e:
print(e)
return database_err, 500
return {'status': rows[0][5]}, 201
def send_request_cssm(self, uuid, oauthToken):
logger.info("contact CSSM debugs")
threads = []
slr_table = SLR_REQUEST_CODE_TABLE_NAME
try:
rows = TokensModel.find_by_uuid(uuid, "device_store")
except Exception as e:
print(e)
logger.error({"message": "Data search operation failed!"}, exc_info=True)
return {"message": "Data search operation failed!"}, 500
if not rows:
logger.error("No Devices with this UUID")
return ({"request": "No Devices with this UUID"}), 400
for row in rows:
logger.info("Launching threads to get auth tokens")
# Updating the response status to Step 3 started
response_update = {'status': "S3s"}
TokensModel.update(uuid, response_update, "upload_info_store")
self.slr.update_status(slr_table, row[0], row[1], "Started", "step2")
''' Bulk DLC Call'''
if TokensModel.find_fileType(uuid) != "sl" and TokensModel.find_slr_type(uuid) == "slr":
domain_name, dlcRequest = SlrRequestCode.get_dlc_conversion_api_body(uuid)
if dlcRequest:
self.slr_bulkDLC(uuid, domain_name, dlcRequest, config.OAUTH_TOKEN)
if TokensModel.find_fileType(uuid) != "sl" and TokensModel.find_slr_type(uuid) == "slrx":
domain_name, dlcRequest = ImportCodes.get_dlc_payload(uuid)
if dlcRequest:
self.slr_bulkDLC(uuid, domain_name, dlcRequest, config.OAUTH_TOKEN)
th = threading.Thread(target=SlrContactCSSM.get_cssm_response, args=(row[6], row[5], oauthToken, row[1],
row[0]))
th.start()
threads.append(th)
logger.info({"request": "accepted"})
return {"request": "accepted"}, 201
def get(self, uuid):
try:
rows = TokensModel.find_by_uuid(uuid, "upload_info_store")
except Exception as e:
print(e)
logger.error({"message": "Data search operation failed!"},
exc_info=True)
return {"message": "Data search operation failed!"}, 500
return {'status': rows[0][5]}, 201
def check_device_type(cls, pid, uuid):
# Initialize dict
device_type_dict = {'device_type': None, 'error': None}
logger.info("In method check_device_type....")
logger.info(" ++++++++ device_type_dict DICT: {}".format(
json.dumps(device_type_dict, indent=4)))
logger.info(" ++++++++ DEVICE STRING: {}".format(
device_type_dict['device_type']))
try:
with open(home + "/config.yaml", 'r') as yamlfile:
cfg = yaml.load(yamlfile)
routers = cfg['pids']['router_pids']
switches = cfg['pids']['switch_pids']
logger.info(" ++++++++ routers string: {}".format(routers))
logger.info(" ++++++++ switches string: {}".format(switches))
# Check device type
if pid in switches:
device_type_dict['device_type'] = "switch"
elif pid in routers:
device_type_dict['device_type'] = "router"
if device_type_dict['device_type']:
print("PID= " + pid)
logger.info(
"====>>>> Success: Got PID matched from config.yaml! <<<<====\n\n"
)
device_pids = ("ASR", "ISR", "CSR", "3850", "3650")
if any(s in pid for s in device_pids):
print("PID found")
TokensModel.update_dlc(uuid, "True")
logger.info(" ++++++++ device_type_dict DICT: {}".format(
json.dumps(device_type_dict, indent=4)))
logger.info(" ++++++++ DEVICE STRING: {}".format(
device_type_dict['device_type']))
logger.info("Leaving method check_device_type...")
return device_type_dict
except Exception:
device_type_dict[
'error'] = 'PID not found! Check config.yaml file!'
logger.error("PID not found! Check config.yaml file!")
raise
def post(self, uuid):
data = Validate.parser.parse_args()
rows = TokensModel.find_by_uuid(uuid, "validation_store")
if not rows:
logger.error("Request with UUID: '{}' doesn't exists.".format(uuid))
return {'message': "Request with UUID: '{}' doesn't exists.".format(uuid)}, 404
domains = TokensModel.find_by_uuid_distinct(uuid, "validation_store")
for domain in domains:
url = "https://apmx.cisco.com/services/api/smart-accounts-and-licensing/v1/accounts/" + domain + \
"/customer/virtual-accounts"
headers = {
"Authorization": data['oauth_token'],
"Content-Type": "application/json"
}
response = requests.request("GET", url, headers=headers)
logger.info(response.json())
logger.info("success")
return {"message": "success"}, 201
def slr_bulkDLC(cls, uuid, domain_name, dlcRequest, bearerToken):
url = "https://apmx.cisco.com/services/api/smart-accounts-and-licensing/v1/accounts/" + domain_name + \
"/dlc_convert"
headers = {
"Authorization": "Bearer " + bearerToken,
"Content-Type": "application/json"
}
if TokensModel.find_fileType(uuid) != "sl" and TokensModel.find_slr_type(uuid) == "slr":
logger.info("Starting bulk dlc conversion for slr")
dlcRequest_dict = {"virtualAccounts": []}
for key, value in dlcRequest.items():
dlcRequest_dict["virtualAccounts"].append({"dlcRequests": value, "name": key})
logger.info("Before deleting device_ip from dlc_data_dict")
logger.info(dlcRequest_dict)
for item in dlcRequest_dict['virtualAccounts'][0]['dlcRequests']:
item['sudi'].pop('device_ip')
logger.info("After deleting device_ip from dlc_data_dict")
logger.info(dlcRequest_dict)
dlc_payload = json.dumps(dlcRequest_dict)
logger.info(dlc_payload)
if TokensModel.find_fileType(uuid) != "sl" and TokensModel.find_slr_type(uuid) == "slrx":
logger.info("Starting bulk dlc conversion for slrx")
logger.info("Before deleting device_ip from dlc_data_dict")
logger.info(dlcRequest)
for item in dlcRequest['virtualAccounts'][0]['dlcRequests']:
item['sudi'].pop('device_ip')
logger.info("After deleting device_ip from dlc_data_dict")
logger.info(dlcRequest)
dlc_payload = json.dumps(dlcRequest)
logger.info(dlc_payload)
try:
for x in range(2):
response = requests.request("POST", url, data=dlc_payload, headers=headers, timeout=10)
try:
response = response.json()
for item in response["devices"]:
conversion_status = "dlc_" + item["conversionStatus"].lower()
udi_pid = item["sudi"]["udiPid"]
device_ip = TokensModel.find_device_ip(uuid,udi_pid)
if conversion_status != "dlc_in_progress":
TokensModel.insert_dlc_status(uuid, device_ip, conversion_status)
logger.info("**********DLC conversion status******")
logger.info(conversion_status)
if conversion_status == "dlc_convert_failed":
logger.info("DLC Failed")
logger.info(response)
break
except Exception as e:
logger.error(e)
logger.error("Failed to parse DLC conversion response ")
time.sleep(180)
except Exception as e:
logger.error(e)
logger.error("DLC conversion request timed out")
def process_request(self, uuid):
threads = []
slr_table = SLR_REQUEST_CODE_TABLE_NAME
try:
rows = TokensModel.find_by_uuid(uuid, "device_store")
except Exception as e:
print(e)
logger.error({"message": "Data search operation failed!"},
exc_info=True)
return {"message": "Data search operation failed!"}, 500
for row in rows:
# Updating the response status to Step 4 started
response_update = {'status': "S4s"}
TokensModel.update(uuid, response_update, "upload_info_store")
self.slr.update_status(slr_table, row[0], row[1], "Started",
"step3")
logger.info(row)
val = self.slr.find_by_uuid_ipaddr(uuid, slr_table, row[1])
logger.info(val)
if val[0][3] == "Completed":
th = threading.Thread(
target=SlrAuthSwitch.send_authorize_information,
args=(row[1], row[2], row[3], ["end"], val[0][6],
val[0][9], val[0][10], uuid))
th.start()
threads.append(th)
else:
self.slr.update_status(slr_table, uuid, row[1],
"Error in previous step", "step3")
rows = self.slr.find_by_step_status(
SLR_REQUEST_CODE_TABLE_NAME, uuid, "Started", "step3")
if len(rows) == 0:
# Updating the response status to Step 4 completed
response_update = {'status': "S4c"}
TokensModel.update(uuid, response_update,
"upload_info_store")
logger.info({"request": "accepted"})
return {"request": "accepted"}, 201
def get(self, uuid):
threads = []
print(uuid)
response = accept
slr_table = slr_req_tbl
try:
rows = TokensModel.find_by_uuid(uuid, "device_store")
except Exception as e:
print(e)
return database_err, 500
for row in rows:
print("Launching threads to get auth tokens")
response_update = {}
response_update['status'] = resp_status_started
TokensModel.update(uuid, response_update, "upload_info_store")
self.slr.update_status(slr_table, row[0], row[1], s_start, step)
th = threading.Thread(target=slrrequestcode.execute_cli_wrapper,
args=(row[1], row[2], row[3],
req_token_command, row[0]))
th.start()
threads.append(th)
return (response), 201
def get(self, uuid):
try:
rows = TokensModel.find_by_uuid(uuid, "slr_request_code_tbl")
except Exception as e:
print(e)
logger.error("Data search operation failed!", exc_info=True)
return {"message": "Data search operation failed!"}, 500
if rows:
# Counter for total no of devices for which auth codes needs to be generated
total_devices = len(rows)
not_started_counter = 0
started_counter = 0
failed_counter = 0
processed_counter = 0
# Updated for all status types
for row in rows:
if row[3] == "NS":
not_started_counter += 1
elif row[3] == "Started":
started_counter += 1
elif row[3] == "Completed":
processed_counter += 1
elif "Error" in row[3]:
failed_counter += 1
processed_counter += 1
if processed_counter == total_devices:
status = "Completed"
elif not_started_counter == total_devices:
status = "NotStarted"
else:
status = "In-Progress"
return {
'message': 'Successfully fetched status of Auth Codes!',
'progress': status,
'total': total_devices,
'failed': failed_counter,
'processed': processed_counter
}, 200
else:
logger.error("Request with UUID: '{}' not found!".format(uuid))
return {
"message": "Request with UUID: '{}' not found!".format(uuid)
}, 404
def get(self, uuid):
try:
rows = TokensModel.join_by_uuid(uuid, "slr_request_code_tbl",
"device_store")
logger.info(
"Printing rows of devices. This should be one per device...")
logger.info(rows)
except Exception as e:
print(e)
logger.error("Data(UUID) search operation failed!", exc_info=True)
return {"message": "Data(UUID) search operation failed!"}, 500
try:
update_row = TokensModel.find_by_uuid(uuid, "upload_info_store")
logger.info("***** Printing row from upload_info_store...")
logger.info(update_row)
logger.info("***** Done printing row from upload_info_store.")
except Exception as e:
print(e)
logger.error("Data(UUID) search operation failed!", exc_info=True)
return {"message": "Data(UUID) search operation failed!"}, 500
if update_row:
if update_row[0][5] != "S2c":
# Changed to 200 from 400 on UI Dev team request
logger.info(
"Request Codes are not yet generated for UUID: {}".format(
uuid))
return {
"message":
"Request Codes are not yet generated for UUID: {}".format(
uuid)
}, 200
if rows:
# Counter for devices with request code generated successfully
counter = 0
devices = []
response_update = {}
response_update['status'] = "S2sx"
try:
TokensModel.update(uuid, response_update, "upload_info_store")
except Exception as e:
print(e)
logger.error(
"Status update operation upload_info_store failed!",
exc_info=True)
return {
'message':
"Status update operation upload_info_store failed!",
'code': 500
}
for row in rows:
licenses = []
# Update individual device status based on ip addr row[1]
# self.slr.update_status("slr_request_code_tbl", row[0], row[1], "Request Code Export Started", "step1")
# Find out if for this device req code generation was successful
if row[2] == "Completed":
counter += 1
# license count and ent tag are passed as list
lic_count_list = str(row[6]).split(" ")
lic_ent_list = str(row[7]).split(" ")
logger.info("lic_count_list:")
logger.info(lic_count_list)
logger.info("lic_ent_list:")
logger.info(lic_ent_list)
for element in range(len(lic_count_list)):
# First handle lic entitlement & count coming in as null string
lic_ent = lic_ent_list[element]
lic_count = lic_count_list[element]
if lic_ent == "":
lic_ent = "None"
if lic_count == "":
lic_count = "None"
licenses.append({
'license-entitlement-tag': lic_ent,
'license-count': lic_count
})
# Handle request code coming in as null string
request_code = row[5]
if request_code == "":
request_code = "None"
devices.append({
'device-uuid': row[11],
'sa-name': row[8],
'va-name': row[9],
'domain': row[10],
'request-code': request_code,
'step1': row[2],
'licenses': licenses
})
logger.info(
"==>> Printing devices from within get method for resource: Tokens <<=="
)
logger.info(devices)
logger.info(
"==>> Printing licenses from within get method for resource: Tokens <<=="
)
logger.info(licenses)
# Update individual device status based on ip addr row[1]
# self.slr.update_status("slr_request_code_tbl", row[0], row[1], "Request Code Export Completed",
# "step1")
# Now update 'upload_info_store' to S2cx
response_update['status'] = "S2cx"
try:
TokensModel.update(uuid, response_update, "upload_info_store")
except Exception as e:
print(e)
logger.error(
"Status update operation upload_info_store failed!",
exc_info=True)
return {
'message':
"Status update operation upload_info_store failed!",
'code': 500
}
try:
registration_row = TokensModel.find_by_uuid(
uuid, "upload_info_store")
except Exception as e:
print(e)
logger.error("Data(UUID) search operation failed!",
exc_info=True)
return {"message": "Data(UUID) search operation failed!"}, 500
try:
domain_name, dlcRequest = SlrRequestCode.get_dlc_conversion_api_body(
uuid)
dlcRequest_dict = {"virtualAccounts": []}
for key, value in dlcRequest.items():
dlcRequest_dict["virtualAccounts"].append({
"dlcRequests": value,
"name": key
})
except Exception as e:
print(e)
logger.error("Data(UUID) search operation failed!",
exc_info=True)
return {"message": "Data(UUID) search operation failed!"}, 500
return {
'registration-name':
registration_row[0][2],
'slr-data-export-type':
'request_codes',
'registration-uuid':
uuid,
'exported-on':
datetime.datetime.fromtimestamp(
time.time()).strftime('%Y-%m-%d %H:%M:%S'),
'total-devices':
len(rows),
'devices-with-success':
counter,
'devices':
devices,
'dlcData':
dlcRequest_dict
}
else:
# Changed to 200 from 404 on UI Dev team request
logger.info("Request with UUID: '{}' not found!".format(uuid))
return {
"message": "Request with UUID: '{}' not found!".format(uuid)
}, 200
def execute_cli_wrapper(cls, device_ip, username, password, cli, uuid):
print("Value of username is " + username + " password " + password)
s = slr("", "", "")
s.update_req_token(slr_req_tbl, uuid, device_ip, "")
result = ""
result_lic_count = ""
try:
lic_rows = s.find_by_uuid_ipaddr(uuid, slr_req_tbl, device_ip)
license = s.get_license(lic_rows[0])
if license is None:
output = slrrequestcode.config_commands(
device_ip, username, password, cli)
print("Value of the output is " + output)
s.update_req_token(slr_req_tbl, uuid, device_ip,
output.split('\n')[-2])
output = slrrequestcode.config_commands(
device_ip, username, password, req_udi_command)
print(output)
udi = (output.split('\n'))
print("Value of udi is " + str(udi))
first = 1
first_count = 1
# result = ""
# result_lic_count = ""
for entitlement_tag in udi:
print(entitlement_tag)
if entitlement_tag_string in entitlement_tag:
if first:
lic = entitlement_tag.split(":")[-1].replace(
" ", "")
first = 0
else:
lic = entitlement_tag.split(":")[-1]
result = result + lic
if count_string in entitlement_tag:
if first_count:
lic_count_string = entitlement_tag.split(
":")[-1].replace(" ", "")
first_count = 0
else:
lic_count_string = entitlement_tag.split(":")[-1]
result_lic_count = result_lic_count + lic_count_string
print("Value of entitlement tag is " + result)
print("Value of count of licenses is " + result_lic_count)
# If we don't get lic ent tag and count from the device, indicate error
if (result is "") or (result_lic_count is ""):
result = "LIC_ENT_TAG_NOT_FOUND"
result_lic_count = "LIC_COUNT_NOT_FOUND"
s.update_entitlement_tag(slr_req_tbl, uuid, device_ip, result)
s.update_license_count(slr_req_tbl, uuid, device_ip,
result_lic_count)
else:
output = slrrequestcode.config_commands(
device_ip, username, password, cli)
print("Value of the output is " + output)
s.update_req_token(slr_req_tbl, uuid, device_ip,
output.split('\n')[-2])
s.update_entitlement_tag(slr_req_tbl, uuid, device_ip, license)
# If we don't get lic ent tag and count from the device, it is considered as failed
if (result is "LIC_ENT_TAG_NOT_FOUND") or (result_lic_count is
"LIC_COUNT_NOT_FOUND"):
s.update_status(slr_req_tbl, uuid, device_ip,
"License details not found from the device",
step)
else:
s.update_status(slr_req_tbl, uuid, device_ip, s_done, step)
except Exception as e:
print(e)
s.update_status(slr_req_tbl, uuid, device_ip,
str(e).split(":")[0], step)
# Added 04/16/19 - As export button and get auth key button is enabled eventhough
# connection to device timed-out
response_update = {}
response_update['status'] = resp_status_failed
TokensModel.update(uuid, response_update, "upload_info_store")
rows = s.find_by_step_status(slr_req_tbl, uuid, s_start, step)
rows_completed = s.find_by_step_status(slr_req_tbl, uuid, s_done, step)
if (len(rows) == 0) and (len(rows_completed) != 0):
response_update = {}
response_update['status'] = resp_status_complete
TokensModel.update(uuid, response_update, "upload_info_store")
del (s)
def get(self, uuid):
try:
rows = TokensModel.join_by_uuid(uuid, "slr_request_code_tbl",
"device_store")
logger.info(
"Printing rows of devices. This should be one per device...")
logger.info(rows)
except Exception as e:
print(e)
logger.error("Data(UUID) search operation failed!", exc_info=True)
return {"message": "Data(UUID) search operation failed!"}, 500
try:
update_row = TokensModel.find_by_uuid(uuid, "upload_info_store")
logger.info("***** Printing row from upload_info_store...")
logger.info(update_row)
logger.info("***** Done printing row from upload_info_store.")
except Exception as e:
print(e)
logger.error("Data(UUID) search operation failed!", exc_info=True)
return {"message": "Data(UUID) search operation failed!"}, 500
if update_row:
if update_row[0][5] != "S3c":
# Changed to 200 from 400 on UI Dev team request
logger.info(
"Auth Codes are not yet generated for UUID: {}".format(
uuid))
return {
"message":
"Auth Codes are not yet generated for UUID: {}".format(
uuid)
}, 200
if rows:
# Counter for devices with auth code generated successfully
counter = 0
devices = []
response_update = {}
response_update['status'] = "S3sx"
# This is a update status for all devices in a request
try:
TokensModel.update(uuid, response_update, "upload_info_store")
except Exception as e:
print(e)
logger.error(
"Auth codes export status update operation upload_info_store failed!",
exc_info=True)
return {
'message':
"Auth codes export status update operation upload_info_store failed!",
'code': 500
}
for row in rows:
# Update individual device status based on ip addr row[1]
# self.slr.update_status("slr_request_code_tbl", row[0], row[1], "Auth Code Export Started", "step2")
# Find out if for this device auth code generation was successful
if row[3] == "Completed":
counter += 1
# Handle auth_code coming in as null string
auth_code = row[12]
if auth_code == "":
auth_code = "None"
devices.append({
'device-uuid': row[11],
'auth-code': auth_code,
'step2': row[3]
})
logger.info(
"==>> Printing devices from within get method for resource: Tokens <<=="
)
logger.info(devices)
# Update individual device status based on ip addr row[1]
# self.slr.update_status("slr_request_code_tbl", row[0], row[1], "Auth Code Export Completed", "step2")
# Now update 'upload_info_store' to S3cx
response_update['status'] = "S3cx"
try:
TokensModel.update(uuid, response_update, "upload_info_store")
except Exception as e:
print(e)
logger.error(
"Auth codes export status update operation upload_info_store failed!",
exc_info=True)
return {
'message':
"Auth codes export status update operation upload_info_store failed!",
'code': 500
}
try:
registration_row = TokensModel.find_by_uuid(
uuid, "upload_info_store")
except Exception as e:
print(e)
logger.error("Data(UUID) search operation failed!",
exc_info=True)
return {"message": "Data(UUID) search operation failed!"}, 500
return {
'registration-name':
registration_row[0][2],
'slr-data-export-type':
'auth_codes',
'registration-uuid':
uuid,
'exported-on':
datetime.datetime.fromtimestamp(
time.time()).strftime('%Y-%m-%d %H:%M:%S'),
'total-devices':
len(rows),
'devices-with-success':
counter,
'devices':
devices
}
else:
# Changed to 200 from 404 on UI Dev team request
logger.error("Request with UUID: '{}' not found!".format(uuid),
exc_info=True)
return {
"message": "Request with UUID: '{}' not found!".format(uuid)
}, 200
def execute_cli_wrapper(cls, device_ip, username, password, cli, uuid):
print("Value of username is " + username + " password " + password)
s = slr("", "", "")
s.update_req_token(slr_req_tbl, uuid, device_ip, "")
try:
lic_rows = s.find_by_uuid_ipaddr(uuid, slr_req_tbl, device_ip)
license = s.get_license(lic_rows[0])
if license is None:
output = slrrequestcode.config_commands(
device_ip, username, password, cli)
print("Value of the output is " + output)
s.update_req_token(slr_req_tbl, uuid, device_ip,
output.split('\n')[-2])
output = slrrequestcode.config_commands(
device_ip, username, password, req_udi_command)
print(output)
udi = (output.split('\n'))
print("Value of udi is " + str(udi))
first = 1
first_count = 1
result = ""
lic_count_string = ""
result_lic_count = ""
for entitlement_tag in udi:
print(entitlement_tag)
if entitlement_tag_string in entitlement_tag:
if first:
lic = entitlement_tag.split(":")[-1].replace(
" ", "")
first = 0
else:
lic = entitlement_tag.split(":")[-1]
result = result + lic
if count_string in entitlement_tag:
if first_count:
lic_count_string = entitlement_tag.split(
":")[-1].replace(" ", "")
first_count = 0
else:
lic_count_string = entitlement_tag.split(":")[-1]
result_lic_count = result_lic_count + lic_count_string
print("Value of entitlement tag is " + result)
print("Value of count of licenses is " + result_lic_count)
s.update_entitlement_tag(slr_req_tbl, uuid, device_ip, result)
s.update_license_count(slr_req_tbl, uuid, device_ip,
result_lic_count)
else:
output = slrrequestcode.config_commands(
device_ip, username, password, cli)
print("Value of the output is " + output)
s.update_req_token(slr_req_tbl, uuid, device_ip,
output.split('\n')[-2])
s.update_entitlement_tag(slr_req_tbl, uuid, device_ip, license)
s.update_status(slr_req_tbl, uuid, device_ip, s_done, step)
except Exception as e:
print(e)
s.update_status(slr_req_tbl, uuid, device_ip,
str(e).split(":")[0], step)
rows = s.find_by_step_status(slr_req_tbl, uuid, s_start, step)
if (len(rows) == 0):
response_update = {}
response_update['status'] = resp_status_complete
TokensModel.update(uuid, response_update, "upload_info_store")
del (s)
def get_cssm_response(cls, domain_name, va_name, oauthToken, device_ip, uuid):
sl_token_dict = {}
sl_token_dict['sl_token'] = ''
sl_token_dict['error'] = ''
final_msg = ""
url = url_prefix.format(domain_name, va_name)
print("Value of the rest api url is ")
print(url)
headers = {
"Authorization": "Bearer " + oauthToken,
"Content-Type": "application/json",
"Cache-Control": "no-cache"
}
payload = "{\"description\": \"SLR Token Automation\",\"expiresAfterDays\": 30,\"exportControlled\":" \
" \"Not Allowed\"}"
s = slr("", "", "")
try:
i = 0
status = s_done
val = s.find_by_uuid_ipaddr(uuid, slr_table, device_ip)
if val[0][2] != s_done:
print(val[0][2])
print(val)
s.update_status(slr_table, uuid, device_ip, "Error in previous step", step)
if (len(rows) == 0):
response_update = {}
response_update['status'] = resp_status_complete
TokensModel.update(uuid, response_update, "upload_info_store")
del(s)
return
tags = val[0][11]
first = 1
licenses = []
try:
license_count = s.get_license_count(val[0]).split(delim);
print(license_count)
for tag in tags.split(delim):
try:
licenses.append({ "entitlementTag":tag, "quantity":license_count[i], "precedence":"LONGEST_TERM_FIRST"})
except Exception as e:
s.update_status(slr_table, uuid, device_ip, "License count and licenses are not set properly", step)
print(e)
rows = s.find_by_step_status(slr_req_tbl, uuid, s_start, step)
if (len(rows) == 0):
response_update = {}
response_update['status'] = resp_status_complete
TokensModel.update(uuid, response_update, "upload_info_store")
del(s)
i = i + 1
except Exception as e:
s.update_status(slr_table, uuid, device_ip, "License is not seperated by spaces", step)
rows = s.find_by_step_status(slr_req_tbl, uuid, s_start, step)
if (len(rows) == 0):
response_update = {}
response_update['status'] = resp_status_complete
TokensModel.update(uuid, response_update, "upload_info_store")
return
body = {"reservationRequests":[{ "reservationCode":val[0][5], "reservationType":"SPECIFIC", "licenses":licenses}]}
print("Reservation request for uuid " + uuid + " for deive with ip " + device_ip)
print("-----------------------------------------------------------------------------")
print(headers)
print(body)
print("-----------------------------------------------------------------------------")
a = json.dumps(body)
response = requests.request("POST", url, data=a, headers=headers, timeout=10)
print(response.content.decode())
if val[0][3] == s_done:
print("Already marked step as completed, don't proceed further. This can happen when rest call takes time. It is more of a race condition, seen once in my testing. Handling for the same")
return
try:
msg = response.json()
print(msg['status'])
if msg['status'] == "ERROR":
status = s_fail + response.json()['statusMessage']
else:
status = s_done
except Exception as e:
print(e)
status = s_fail + "Response from cssm failed"
s.update_status(slr_table, uuid, device_ip, status, step)
try:
print(msg)
print(msg['authorizationCodes'][0])
if (1 == first) :
first = 0
else:
final_msg = final_msg + delim
print(msg['authorizationCodes'][0]['authorizationCode'])
final_msg = final_msg + msg['authorizationCodes'][0]['authorizationCode']
except Exception as e:
print(e)
s.update_authz_response_code(slr_req_tbl, uuid, device_ip, 'Error in getting response from cssm')
s.update_authz_response_code(slr_req_tbl, uuid, device_ip, final_msg)
except Exception as e:
print(e)
rows = s.find_by_step_status(slr_req_tbl, uuid, s_start, step)
if (len(rows) == 0):
response_update = {}
response_update['status'] = resp_status_complete
TokensModel.update(uuid, response_update, "upload_info_store")
del(s)
def post(self):
File.parser.add_argument('registration_type',
type=str,
required=True,
help="This field cannot be blank."
)
data = File.parser.parse_args()
print("OAuth token is:", data['oauth_token'])
# Generate UUID to identify registration request
uuid_str = str(uuid.uuid4())
if 'file' not in request.files:
return {"message": "No File in the request!"}, 400
file = request.files['file']
if file.filename == '':
return {'message': "No File selected!"}, 400
if not File.allowed_file(file.filename):
return {'message': "File type not allowed! Only CSV files are allowed!"}, 400
# Create dictionary for upload_info_store
upload_info_dict = {}
upload_info_dict['uuid'] = uuid_str
upload_info_dict['userid'] = config.USER_ID
upload_info_dict['filename'] = file.filename
upload_info_dict['type'] = data['registration_type']
upload_info_dict['timestamp'] = datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S')
upload_info_dict['status'] = "csv_file_uploaded"
# Also set REGISTRATION_NAME as filename in config file
config.REGISTRATION_NAME = file.filename
# Create dictionaries for device_store, validation_store, device_status_store
converted_json, converted_validation_json, converted_status_json = File.csv_to_json(file)
# Enter data into the database store device_store
if TokensModel.find_by_uuid(uuid_str, "device_store"):
return {'message': "Request with UUID: '{}' already exists.".format(uuid)}, 400
try:
TokensModel.insert(uuid_str, converted_json, "device_store")
except Exception as e:
print(e)
return {"message": "Data insert operation device_store failed!"}, 500
# Enter data into the database store account_validation
if TokensModel.find_by_uuid(uuid_str, "validation_store"):
return {'message': "Request with UUID: '{}' already exists.".format(uuid)}, 400
try:
TokensModel.insert(uuid_str, converted_validation_json, "validation_store")
except Exception as e:
print(e)
return {"message": "Data insert operation validation_store failed!"}, 500
# Enter data into the database store device_status_store
if TokensModel.find_by_uuid(uuid_str, "device_status_store"):
return {'message': "Request with UUID: '{}' already exists.".format(uuid)}, 400
try:
TokensModel.insert(uuid_str, converted_status_json, "device_status_store")
except Exception as e:
print(e)
return {"message": "Data insert operation device_status_store failed!"}, 500
try:
if data['registration_type'] == 'slr':
TokensModel.insert(uuid_str, converted_json, "slr_request_code_tbl")
except Exception as e:
print (e)
return {"message": "Data insert operation slr_request_code_tbl failed!"}, 500
# Enter data into the database store upload_info_store
if TokensModel.find_by_uuid(uuid_str, "upload_info_store"):
return {'message': "Request with UUID: '{}' already exists.".format(uuid)}, 400
try:
TokensModel.insert(uuid_str, [upload_info_dict], "upload_info_store")
except Exception as e:
print(e)
return {"message": "Data insert operation failed!"}, 500
config.NO_OF_DEVICES = len(converted_json)
config.NO_OF_PAGES = ceil(len(converted_json)/10)
new_request = {
'uuid': uuid_str,
'totalpages': config.NO_OF_PAGES,
'message': 'File is uploaded!'
}
# For debugging
print(new_request)
if TokensModel.find_by_uuid(uuid_str, "validation_store"):
print("Printed validation_store")
if TokensModel.find_by_uuid(uuid_str, "device_status_store"):
print("Printed device_status_store")
if TokensModel.find_by_uuid(uuid_str, "upload_info_store"):
print("Printed upload_info_store")
return new_request, 201
def execute_cli_wrapper(cls, device_ip, username, password, cli, uuid, sa,
va, domain):
logger.info("Value of username is " + username + " password " +
password)
config.ERROR, sw_ver_str, device_type_dict = Helper.check_dlc_required(
device_ip, uuid, sa, va, domain, "x", username, password)
dlc_required = TokensModel.select_dlc(uuid)
logger.info("DLC_Required Flag set to:" + dlc_required)
if not config.ERROR:
if sw_ver_str and device_type_dict['device_type'] is not None:
s = slr("", "", "")
s.update_req_token(SLR_REQUEST_CODE_TABLE_NAME, uuid,
device_ip, "")
result = ""
result_lic_count = ""
try:
if dlc_required == "True":
dlc_process_status = SlrRequestCode.check_dlc_status_on_device(
device_ip, username, password, dlc_proc_stat_cmd)
if dlc_process_status != '' and dlc_process_status == 'Not Complete':
dlc_conversion_data = SlrRequestCode.execute_dlc_cli(
device_ip, username, password,
dlc_conversion_command)
if dlc_conversion_data != '':
logger.info("DLC_conversion_data")
logger.info(type(dlc_conversion_data))
logger.info(dlc_conversion_data)
SlrRequestCode.generate_dlc_data_dict(
device_ip, dlc_conversion_data, va)
SlrRequestCode.insert_dlc_data_to_table(
uuid, device_ip, dlc_conversion_data)
lic_rows = s.find_by_uuid_ipaddr(
uuid, SLR_REQUEST_CODE_TABLE_NAME, device_ip)
device_license = s.get_license(lic_rows[0])
if device_license is None:
output = SlrRequestCode.config_commands(
device_ip, username, password, cli)
logger.info("Value of the output is " + output)
req_code = output.split('\n')[-2]
if req_code.find("Request code:") != -1:
data = req_code.split("code: ")
req_code = data[1]
s.update_req_token(SLR_REQUEST_CODE_TABLE_NAME, uuid,
device_ip, req_code)
output = SlrRequestCode.config_commands(
device_ip, username, password, req_udi_command)
logger.info(output)
udi = (output.split('\n'))
logger.info("Value of udi is " + str(udi))
first = 1
first_count = 1
for entitlement_tag in udi:
logger.info(entitlement_tag)
if "Entitlement tag" in entitlement_tag:
if first:
lic = entitlement_tag.split(
":")[-1].replace(" ", "")
first = 0
else:
lic = entitlement_tag.split(":")[-1]
result = result + lic
if "Count:" in entitlement_tag:
if first_count:
lic_count_string = entitlement_tag.split(
":")[-1].replace(" ", "")
first_count = 0
else:
lic_count_string = entitlement_tag.split(
":")[-1]
result_lic_count = result_lic_count + lic_count_string
logger.info("Value of entitlement tag is " + result)
logger.info("Value of count of licenses is " +
result_lic_count)
# If we don't get lic ent tag and count from the device, indicate error
if (result == "") or (result_lic_count == ""):
result = "LIC_ENT_TAG_NOT_FOUND"
result_lic_count = "LIC_COUNT_NOT_FOUND"
s.update_entitlement_tag(SLR_REQUEST_CODE_TABLE_NAME,
uuid, device_ip, result)
s.update_license_count(SLR_REQUEST_CODE_TABLE_NAME,
uuid, device_ip,
result_lic_count)
else:
output = SlrRequestCode.config_commands(
device_ip, username, password, cli)
logger.info("Value of the output is " + output)
req_code = output.split('\n')[-2]
if req_code.find("Request code:") != -1:
data = req_code.split("code: ")
req_code = data[1]
s.update_req_token(SLR_REQUEST_CODE_TABLE_NAME, uuid,
device_ip, req_code)
s.update_entitlement_tag(SLR_REQUEST_CODE_TABLE_NAME,
uuid, device_ip,
device_license)
# If we don't get lic ent tag and count from the device, it is considered as failed
if (result == "LIC_ENT_TAG_NOT_FOUND") or (
result_lic_count == "LIC_COUNT_NOT_FOUND"):
s.update_status(
SLR_REQUEST_CODE_TABLE_NAME, uuid, device_ip,
"License details not found from the "
"device", "step1")
else:
s.update_status(SLR_REQUEST_CODE_TABLE_NAME, uuid,
device_ip, "Completed", "step1")
except Exception as e:
print(e)
s.update_status(SLR_REQUEST_CODE_TABLE_NAME, uuid,
device_ip,
str(e).split(":")[0], "step1")
# Added 04/16/19 - As export button and get auth key button is enabled eventhough
# connection to device timed-out
# Updating response status to Step 2 failed
response_update = {'status': "S2f"}
TokensModel.update(uuid, response_update,
"upload_info_store")
rows = s.find_by_step_status(SLR_REQUEST_CODE_TABLE_NAME, uuid,
"Started", "step1")
rows_completed = s.find_by_step_status(
SLR_REQUEST_CODE_TABLE_NAME, uuid, "Completed", "step1")
if (len(rows) == 0) and (len(rows_completed) != 0):
# Updating the response status to Step 2 completed
response_update = {'status': "S2c"}
TokensModel.update(uuid, response_update,
"upload_info_store")
del s
else:
logger.info("==>> Unsupported Network Device type...")
response = {
'ipaddr': device_ip,
'username': username,
'password': password,
'sa_name': sa,
'va_name': va,
'domain': domain,
'status': 'Unsupported Device PID!'
}
config.ERROR = True
TokensModel.update(uuid, response, "device_status_store")
else:
logger.error("No connectivity to the device...")
response_update = {
'ipaddr': device_ip,
'username': username,
'password': password,
'sa_name': sa,
'va_name': va,
'domain': domain,
'status': 'No Connectivity!'
}
config.ERROR = True
TokensModel.update(uuid, response_update, "device_status_store")
def get_cssm_response(cls, domain_name, va_name, oauthToken, device_ip, uuid):
final_msg = ""
url = URL_PREFIX.format(domain_name, va_name)
logger.info("Value of the rest api url is ")
logger.info(url)
headers = {
"Authorization": "Bearer " + oauthToken,
"Content-Type": "application/json",
"Cache-Control": "no-cache"
}
s = slr("", "", "")
try:
i = 0
val = s.find_by_uuid_ipaddr(uuid, slr_table_name, device_ip)
if val[0][2] != "Completed":
logger.info(val[0][2])
logger.info(val)
logger.error("Error in previous step")
s.update_status(slr_table_name, uuid, device_ip, "Error in previous step", "step2")
rows = s.find_by_step_status(SLR_REQUEST_CODE_TABLE_NAME, uuid, "Started", "step2")
if len(rows) == 0:
# Updating the response status to Step 3 Complete
response_update = {'status': "S3c"}
TokensModel.update(uuid, response_update, "upload_info_store")
return
tags = val[0][11]
licenses = []
try:
license_count = s.get_license_count(val[0]).split(delim)
logger.info(license_count)
for tag in tags.split(delim):
if int(license_count[i]) > 0:
try:
licenses.append(
{"entitlementTag": tag, "quantity": license_count[i], "precedence":
"LONGEST_TERM_FIRST"})
except Exception as e:
s.update_status(slr_table_name, uuid, device_ip,
"License count and licenses are not set properly",
"step2")
print(e)
logger.error("License count and licenses are not set properly", exc_info=True)
rows = s.find_by_step_status(SLR_REQUEST_CODE_TABLE_NAME, uuid, "Started", "step2")
if len(rows) == 0:
# Updating the response status to Step 3 Complete
response_update = {'status': "S3c"}
TokensModel.update(uuid, response_update, "upload_info_store")
i = i + 1
except Exception as e:
print(e)
s.update_status(slr_table_name, uuid, device_ip, "License is not separated by spaces", "step2")
logger.error("License is not separated by spaces", exc_info=True)
rows = s.find_by_step_status(SLR_REQUEST_CODE_TABLE_NAME, uuid, "Started", "step2")
if len(rows) == 0:
# Updating the response status to Step 3 Complete
response_update = {'status': "S3c"}
TokensModel.update(uuid, response_update, "upload_info_store")
return
body = {"reservationRequests": [
{"reservationCode": val[0][5], "reservationType": "SPECIFIC", "licenses": licenses}]}
logger.info("Reservation request for uuid " + uuid + " for device with ip " + device_ip)
logger.info(headers)
logger.info(body)
a = json.dumps(body)
# New call added for response with retries
response = SlrContactCSSM.send_post_with_retries(url, a, headers, 30)
# response = requests.request("POST", url, data=a, headers=headers, timeout=10)
logger.info("Now printing response.json & contents.decode as per old call...")
logger.info(response.json())
logger.info(response.content.decode())
if val[0][3] == "Completed":
logger.info("Already marked step as completed, don't proceed further. This can happen when rest call \
takes time. It is more of a race condition, seen once in my testing. Handling for the same")
return
try:
msg = response.json()
logger.info(msg['status'])
if msg['status'] == "ERROR":
status = "Fail: " + response.json()['statusMessage']
else:
status = "Completed"
except Exception as e:
print(e)
status = "Fail: " + "Response from cssm failed"
logger.error(status, exc_info=True)
s.update_status(slr_table_name, uuid, device_ip, status, "step2")
try:
logger.info(msg)
logger.info(msg['authorizationCodes'][0])
print(msg)
logger.info(msg['authorizationCodes'][0]['authorizationCode'])
final_msg = final_msg + msg['authorizationCodes'][0]['authorizationCode']
print(final_msg)
except Exception as e:
print(e)
s.update_authz_response_code(SLR_REQUEST_CODE_TABLE_NAME, uuid, device_ip, 'Error in getting response '
'from cssm')
logger.error("Error in getting response from CSSM", exc_info=True)
s.update_authz_response_code(SLR_REQUEST_CODE_TABLE_NAME, uuid, device_ip, final_msg)
except Exception as e:
logger.info("@@@@@ Printing Exception from main CSSM reserve license call...")
print(e)
logger.error('Error! Code: {c}, Message, {m}'.format(c=type(e).__name__, m=str(e)))
# Following code is added to catch HTTP ConnectionError (Wrong URL etc)
status = "Fail: " + str(type(e).__name__)
s.update_authz_response_code(SLR_REQUEST_CODE_TABLE_NAME, uuid, device_ip, 'Error in getting response '
'from cssm')
s.update_status(slr_table_name, uuid, device_ip, status, "step2")
rows = s.find_by_step_status(SLR_REQUEST_CODE_TABLE_NAME, uuid, "Started", "step2")
rows_completed = s.find_by_step_status(SLR_REQUEST_CODE_TABLE_NAME, uuid, "Completed", "step2")
if (len(rows) == 0) and (len(rows_completed) != 0):
# Updating the response status to Step 3 Complete
response_update = {'status': "S3c"}
TokensModel.update(uuid, response_update, "upload_info_store")
def update_auth_codes_slr(cls, validated_json):
s = slr("", "", "")
# Start extracting required fields from json
uuid = validated_json['registration-uuid']
# registration_name = validated_json['registration-name']
# First check if devices with this UUID already exists
try:
rows_slr = TokensModel.find_by_uuid(uuid, "slr_request_code_tbl")
rows = TokensModel.find_by_uuid(uuid, "device_store")
except Exception as e:
print(e)
return {"message": "Data search operation failed!", 'code': 500}
if not rows_slr:
# Changed to 200 from 400 on UI Dev team request
print("==>> UUID doesn't exists in slr_request_code_tbl...")
return {
"message":
"Registration request with this UUID doesn't exists!",
'code': 200
}
if not rows:
# Changed to 200 from 400 on UI Dev team request
print("==>> UUID doesn't exists in device_store...")
return {
"message":
"Registration request with this UUID doesn't exists!",
'code': 200
}
# Prepare fields for upload_info_store
upload_info_store_dict = {}
upload_info_store_dict['status'] = "S3si"
try:
TokensModel.update(uuid, upload_info_store_dict,
"upload_info_store")
except Exception as e:
print(e)
return {
'message': "Status update operation upload_info_store failed!",
'code': 500
}
for device in validated_json['devices']:
# Update status for step2 (Auth-Code generation) for each device
try:
s.update_status_device_uuid("slr_request_code_tbl", uuid,
device['device-uuid'],
device['step2'], 'step2')
except Exception as e:
print(
"++>> Not able to update step2 status in slr_request_code_tbl..."
)
print(e)
# Update Auth-Code for each device
try:
s.update_authz_response_code_device_uuid(
"slr_request_code_tbl", uuid, device['device-uuid'],
device['auth-code'])
except Exception as e:
print(
"++>> Not able to update Auth-Code in slr_request_code_tbl..."
)
print(e)
# Prepare fields for upload_info_store
upload_info_store_dict['status'] = "S3ci"
# We are updating timestamp only when step2 is complete
upload_info_store_dict['timestamp'] = datetime.datetime.fromtimestamp(
time.time()).strftime('%Y-%m-%d %H:%M:%S')
try:
TokensModel.update(uuid, upload_info_store_dict,
"upload_info_store")
except Exception as e:
print(e)
return {
'message':
"Status update operation slr_request_code_tbl failed!",
'code': 500
}
# Finally return success - 201
return {'message': "Tables successfully updated!", 'code': 201}
def update_req_codes_slr(cls, validated_json):
# s = slr("", "", "")
# Start extracting required fields from json
uuid = validated_json['registration-uuid']
registration_name = validated_json['registration-name']
# First check if devices with this UUID already exists
try:
rows_slr = TokensModel.find_by_uuid(uuid, "slr_request_code_tbl")
rows = TokensModel.find_by_uuid(uuid, "device_store")
except Exception as e:
print(e)
return {"message": "Data search operation failed!", 'code': 500}
if rows_slr:
# Changed to 200 from 400 on UI Dev team request
print("==>> UUID already exists in slr_request_code_tbl...")
return {
"message":
"Registration request with this UUID already exists!",
'code': 200
}
if rows:
# Changed to 200 from 400 on UI Dev team request
print("==>> UUID already exists in device_store...")
return {
"message":
"Registration request with this UUID already exists!",
'code': 200
}
# Creat update_slr_reqcode_table_dict
insert_slr_reqcode_table_list = []
insert_device_store_table_list = []
insert_upload_info_store_table_list = []
for device in validated_json['devices']:
# Traverse through validated_json dictionary and create a list of flat key-value pair dict
each_device_reqcode_dict = {}
each_device_store_dict = {}
each_device_upload_info_store_dict = {}
# Initialize lic_count_str & lic_ent_tag_str
lic_count_str, lic_ent_tag_str = "", ""
# Prepare fields for slr_request_code_tbl
each_device_reqcode_dict['uuid'] = uuid
each_device_reqcode_dict['ipaddr'] = device['device-uuid']
each_device_reqcode_dict['step1'] = device['step1']
each_device_reqcode_dict['step2'] = "NS"
each_device_reqcode_dict['step3'] = "NS"
each_device_reqcode_dict['authz_req_code'] = device['request-code']
each_device_reqcode_dict['authz_response_code'] = ""
each_device_reqcode_dict['license'] = ""
for license in device['licenses']:
print("\n\n")
print("**** Printing license sub-json...")
print(license)
lic_count_str += license['license-count'] + " "
lic_ent_tag_str += license['license-entitlement-tag'] + " "
each_device_reqcode_dict['license_count'] = lic_count_str.strip()
each_device_reqcode_dict[
'license_entitlement_tag'] = lic_ent_tag_str.strip()
print("\n\n")
print("**** Importing license count...")
print(each_device_reqcode_dict['license_count'])
print("**** Importing license cent tag...")
print(each_device_reqcode_dict['license_entitlement_tag'])
print("\n\n")
each_device_reqcode_dict['tftp_server_ip'] = ""
each_device_reqcode_dict['tftp_server_path'] = ""
each_device_reqcode_dict['device_uuid'] = device['device-uuid']
# Prepare fields for device_store
each_device_store_dict['uuid'] = uuid
each_device_store_dict['ipaddr'] = device['device-uuid']
each_device_store_dict['username'] = "******"
each_device_store_dict['password'] = "******"
each_device_store_dict['sa_name'] = device['sa-name']
each_device_store_dict['va_name'] = device['va-name']
each_device_store_dict['domain'] = device['domain']
each_device_store_dict['device_uuid'] = device['device-uuid']
# Prepare fields for upload_info_store
each_device_upload_info_store_dict['uuid'] = uuid
each_device_upload_info_store_dict['userid'] = "NA"
each_device_upload_info_store_dict['filename'] = registration_name
each_device_upload_info_store_dict['type'] = "slr"
each_device_upload_info_store_dict[
'timestamp'] = datetime.datetime.fromtimestamp(
time.time()).strftime('%Y-%m-%d %H:%M:%S')
# each_device_upload_info_store_dict['status'] = "S2c"
each_device_upload_info_store_dict['status'] = "S2ci"
# Now add each_device_reqcode_dict to update_slr_reqcode_table_list
insert_slr_reqcode_table_list.append(each_device_reqcode_dict)
# Now add each_device_store_dict to update_device_store_table_list
insert_device_store_table_list.append(each_device_store_dict)
# Now add each_device_upload_info_store_dict to insert_upload_info_store_table_list
insert_upload_info_store_table_list.append(
each_device_upload_info_store_dict)
# Now print list of flat key-value pair dict - update_slr_reqcode_table_list
print(
"==>> Printing update_slr_reqcode_table_list before inserting into slr_request_code_tbl..."
)
print(insert_slr_reqcode_table_list)
# Now print list of flat key-value pair dict - update_device_store_table_list
print(
"==>> Printing update_device_store_table_list before inserting into device_store..."
)
print(insert_device_store_table_list)
# Now print list of flat key-value pair dict - insert_upload_info_store_table_list
print(
"==>> Printing insert_upload_info_store_table_list before inserting into upload_info_store"
)
print(insert_upload_info_store_table_list)
try:
TokensModel.insert_slr(uuid, insert_slr_reqcode_table_list,
"slr_request_code_tbl")
print(
"==>> Now printing slr_request_code_tbl after updateing request_codes..."
)
if TokensModel.find_by_uuid(uuid, "slr_request_code_tbl"):
print("==>> Done printing slr_request_code_tbl")
except Exception as e:
print(
"==>> Printig exception while inserting data into slr_request_code_tbl..."
)
print(e)
return {
'message':
"Data insert operation slr_request_code_tbl failed!",
'code': 500
}
try:
TokensModel.insert(uuid, insert_device_store_table_list,
"device_store")
print(
"==>> Now printing device_store after updating sa, va, domain..."
)
if TokensModel.find_by_uuid(uuid, "device_store"):
print("==>> Done printing device_store")
except Exception as e:
print(
"==>> Printig exception while inserting data into device_store..."
)
print(e)
return {
'message': "Data insert operation device_store failed!",
'code': 500
}
try:
TokensModel.insert(uuid, insert_upload_info_store_table_list,
"upload_info_store")
print(
"==>> Now printing upload_info_store after updating registration-name, status..."
)
if TokensModel.find_by_uuid(uuid, "upload_info_store"):
print("==>> Done printing upload_info_store")
except Exception as e:
print(
"==>> Printig exception while inserting data into upload_info_store..."
)
print(e)
return {
'message': "Data insert operation device_store failed!",
'code': 500
}
# Finally return success - 201
return {'message': "Tables successfully updated!", 'code': 201}
def post(self):
File.parser.add_argument('registration_type',
type=str,
required=True,
help="This field cannot be blank.")
data = File.parser.parse_args()
logger.info("OAuth token is: {}".format(data['oauth_token']))
# Generate UUID to identify registration request
uuid_str = str(uuid.uuid4())
config.UUID = uuid_str
# Valid registration_type list
registration_list = ['sl', 'slr']
if data['registration_type'] not in registration_list:
logger.error("Registration type is not valid!")
return {'message': "Registration type is not valid!"}, 400
if 'file' not in request.files:
logger.error("No File in the request!")
return {"message": "No File in the request!"}, 400
file = request.files['file']
if file.filename == '':
logger.error("No File selected!")
return {'message': "No File selected!"}, 400
if not File.allowed_file(file.filename):
logger.error("File type not allowed! Only CSV files are allowed!")
return {
'message': "File type not allowed! Only CSV files are allowed!"
}, 400
# Validate each field/column of CSV file
validate_flag, errors, df = File.validate_csv(
file, data['registration_type'])
if not validate_flag:
logger.error("CSV file validation failed!: '{}'".format(errors))
return {
'message': "CSV file validation failed!: '{}'".format(errors)
}, 400
# Create dictionary for upload_info_store
upload_info_dict = {
'uuid':
uuid_str,
'userid':
config.USER_ID,
'filename':
file.filename,
'type':
data['registration_type'],
'timestamp':
datetime.datetime.fromtimestamp(
time.time()).strftime('%Y-%m-%d %H:%M:%S'),
'status':
"csv_file_uploaded"
}
# Also set REGISTRATION_NAME as filename in config file
config.REGISTRATION_NAME = file.filename
# Create dictionaries for device_store, validation_store, device_status_store
converted_json, converted_validation_json, converted_status_json = File.csv_to_json(
df)
# Enter data into the database store device_store
if TokensModel.find_by_uuid(uuid_str, "device_store"):
logger.info("Request with UUID: '{}' already exists.".format(uuid))
return {
'message':
"Request with UUID: '{}' already exists.".format(uuid)
}, 400
try:
TokensModel.insert(uuid_str, converted_json, "device_store")
except Exception as e:
print(e)
logger.error("Data insert operation device_store failed!",
exc_info=True)
return {
"message": "Data insert operation device_store failed!"
}, 500
# Enter data into the database store account_validation
if TokensModel.find_by_uuid(uuid_str, "validation_store"):
logger.info("Request with UUID: '{}' already exists.".format(uuid))
return {
'message':
"Request with UUID: '{}' already exists.".format(uuid)
}, 400
try:
TokensModel.insert(uuid_str, converted_validation_json,
"validation_store")
except Exception as e:
print(e)
logger.error("Data insert operation validation_store failed!",
exc_info=True)
return {
"message": "Data insert operation validation_store failed!"
}, 500
# Enter data into the database store device_status_store
if TokensModel.find_by_uuid(uuid_str, "device_status_store"):
logger.info("Request with UUID: '{}' already exists.".format(uuid))
return {
'message':
"Request with UUID: '{}' already exists.".format(uuid)
}, 400
try:
TokensModel.insert(uuid_str, converted_status_json,
"device_status_store")
except Exception as e:
print(e)
logger.error("Data insert operation device_status_store failed!",
exc_info=True)
return {
"message": "Data insert operation device_status_store failed!"
}, 500
try:
if data['registration_type'] == 'slr':
TokensModel.insert(uuid_str, converted_json,
"slr_request_code_tbl")
except Exception as e:
print(e)
logger.error("Data insert operation slr_request_code_tbl failed!",
exc_info=True)
return {
"message": "Data insert operation slr_request_code_tbl failed!"
}, 500
# Enter data into the database store upload_info_store
if TokensModel.find_by_uuid(uuid_str, "upload_info_store"):
logger.info("Request with UUID: '{}' already exists.".format(uuid))
return {
'message':
"Request with UUID: '{}' already exists.".format(uuid)
}, 400
try:
TokensModel.insert(uuid_str, [upload_info_dict],
"upload_info_store")
except Exception as e:
print(e)
logger.error("Data insert operation failed!", exc_info=True)
return {"message": "Data insert operation failed!"}, 500
config.NO_OF_DEVICES = len(converted_json)
config.NO_OF_PAGES = ceil(len(converted_json) / 10)
new_request = {
'uuid': uuid_str,
'totalpages': config.NO_OF_PAGES,
'message': 'File is uploaded!'
}
# For debugging
logger.info(new_request)
if TokensModel.find_by_uuid(uuid_str, "validation_store"):
logger.info("Printed validation_store")
if TokensModel.find_by_uuid(uuid_str, "device_status_store"):
logger.info("Printed device_status_store")
if TokensModel.find_by_uuid(uuid_str, "upload_info_store"):
logger.info("Printed upload_info_store")
logger.info(
"The request has been fulfilled and has resulted in one or more new resources being created"
)
return new_request, 201
