def write_software_profile_info(self):
self.ws.write(
self.row, 0,
'Software Profile: ' + self.conformance_report.software_profile,
XLSWriter.style_bold)
self.row += 2
software_profile_packages = self.conformance_report.software_profile_packages.split(
',')
smu_loader = None
platform, release = get_platform_and_release(software_profile_packages)
if platform != UNKNOWN and release != UNKNOWN:
smu_loader = SMUInfoLoader(platform, release)
for software_profile_package in software_profile_packages:
self.ws.write(self.row, 0, software_profile_package)
if smu_loader is not None and smu_loader.is_valid:
smu_info = smu_loader.get_smu_info(
software_profile_package.replace(
'.' + smu_loader.file_suffix, ''))
if smu_info is not None:
self.ws.write(self.row, 1, smu_info.description)
self.row += 1
self.row += 1
def api_get_missing_prerequisite_list():
"""
Given a SMU list, return any missing pre-requisites. The
SMU entries returned also have the file extension appended.
"""
hostname = request.args.get('hostname')
# The SMUs selected by the user to install
smu_list = request.args.get('smu_list').split()
rows = []
platform, release = SMUInfoLoader.get_platform_and_release(smu_list)
if platform != UNKNOWN and release != UNKNOWN:
smu_loader = SMUInfoLoader(platform, release)
prerequisite_list = get_missing_prerequisite_list(smu_list)
host_packages = get_host_active_packages(hostname)
for smu_name in prerequisite_list:
# If the missing pre-requisites have not been installed
# (i.e. not in the Active/Active-Committed), include them.
if not host_packages_contains(host_packages, smu_name):
smu_info = smu_loader.get_smu_info(smu_name.replace('.' + smu_loader.file_suffix, ''))
description = '' if smu_info is None else smu_info.description
rows.append({'smu_entry': smu_name, 'description': description})
return jsonify(**{'data': rows})
def api_get_conformance_report_software_profile_packages(id):
rows = []
db_session = DBSession()
conformance_report = get_conformance_report_by_id(db_session, id)
if conformance_report is not None:
software_profile_packages = conformance_report.software_profile_packages.split(
',')
smu_loader = None
platform, release = get_platform_and_release(software_profile_packages)
if platform != UNKNOWN and release != UNKNOWN:
smu_loader = SMUInfoLoader(platform, release)
for software_profile_package in software_profile_packages:
description = ''
if smu_loader is not None and smu_loader.is_valid:
smu_info = smu_loader.get_smu_info(
software_profile_package.replace(
'.' + smu_loader.file_suffix, ''))
if smu_info is not None:
description = smu_info.description
rows.append({
'software_profile_package': software_profile_package,
'description': description
})
return jsonify(**{'data': rows})
def export_software_information(platform, release):
smu_loader = SMUInfoLoader(platform, release)
if not smu_loader.is_valid:
return jsonify({'status': 'Failed'})
export_format = request.args.get('export_format')
export_layout = request.args.get('export_layout')
export_filter = request.args.get('filter')
if export_filter == 'Optimal':
smu_list = smu_loader.get_optimal_smu_list()
sp_list = smu_loader.get_optimal_sp_list()
else:
smu_list = smu_loader.get_smu_list()
sp_list = smu_loader.get_sp_list()
if export_format == ExportInformationFormat.HTML:
if export_layout == ExportSoftwareInformationLayout.CONCISE:
writer = ExportSoftwareInfoHTMLConciseWriter(user=current_user, smu_loader=smu_loader,
smu_list=smu_list, sp_list=sp_list)
else:
writer = ExportSoftwareInfoHTMLDefaultWriter(user=current_user, smu_loader=smu_loader,
smu_list=smu_list, sp_list=sp_list)
else:
if export_layout == ExportSoftwareInformationLayout.CONCISE:
writer = ExportSoftwareInfoExcelConciseWriter(user=current_user, smu_loader=smu_loader,
smu_list=smu_list, sp_list=sp_list)
else:
writer = ExportSoftwareInfoExcelDefaultWriter(user=current_user, smu_loader=smu_loader,
smu_list=smu_list, sp_list=sp_list)
return send_file(writer.write_report(), as_attachment=True)
def get_missing_prerequisite_list(smu_list):
result_list = []
platform, release = get_platform_and_release(smu_list)
if platform == UNKNOWN or release == UNKNOWN:
return result_list
# Load the SMU information
smu_loader = SMUInfoLoader(platform, release)
smu_info_list= []
smu_name_set = set()
for line in smu_list:
smu_name = get_smu_lookup_name(line)
smu_info = smu_loader.get_smu_info(smu_name)
if smu_info is None or smu_name in smu_name_set:
continue
smu_name_set.add(smu_name)
smu_info_list.append(smu_info)
if len(smu_info_list) > 0:
# Exclude all the superseded SMUs in smu_info_list
excluded_supersede_list = get_excluded_supersede_list(smu_info_list)
missing_required_prerequisite_dict = \
get_missing_required_prerequisites(smu_loader, excluded_supersede_list)
missing_required_prerequisite_set = get_unique_set_from_dict(missing_required_prerequisite_dict)
for pre_requisite_smu in missing_required_prerequisite_set:
result_list.append(pre_requisite_smu + '.' + smu_loader.file_suffix)
return result_list
def api_get_missing_prerequisite_list():
"""
Given a SMU list, return any missing pre-requisites. The
SMU entries returned also have the file extension appended.
"""
hostname = request.args.get('hostname')
# The SMUs selected by the user to install
smu_list = request.args.get('smu_list').split()
rows = []
platform, release = SMUInfoLoader.get_platform_and_release(smu_list)
if platform != UNKNOWN and release != UNKNOWN:
smu_loader = SMUInfoLoader(platform, release)
prerequisite_list = get_missing_prerequisite_list(smu_list)
host_packages = get_host_active_packages(hostname)
for smu_name in prerequisite_list:
# If the missing pre-requisites have not been installed
# (i.e. not in the Active/Active-Committed), include them.
if not host_packages_contains(host_packages, smu_name):
smu_info = smu_loader.get_smu_info(
smu_name.replace('.' + smu_loader.file_suffix, ''))
description = '' if smu_info is None else smu_info.description
rows.append({
'smu_entry': smu_name,
'description': description
})
return jsonify(**{'data': rows})
def get_missing_prerequisite_list(smu_list):
result_list = []
platform, release = get_platform_and_release(smu_list)
if platform == UNKNOWN or release == UNKNOWN:
return result_list
# Load the SMU information
smu_loader = SMUInfoLoader(platform, release)
smu_info_list= []
smu_name_set = set()
for line in smu_list:
smu_name = get_smu_lookup_name(line)
smu_info = smu_loader.get_smu_info(smu_name)
if smu_info is None or smu_name in smu_name_set:
continue
smu_name_set.add(smu_name)
smu_info_list.append(smu_info)
if len(smu_info_list) > 0:
# Exclude all the superseded SMUs in smu_info_list
excluded_supersede_list = get_excluded_supersede_list(smu_info_list)
missing_required_prerequisite_dict = \
get_missing_required_prerequisites(smu_loader, excluded_supersede_list)
missing_required_prerequisite_set = get_unique_set_from_dict(missing_required_prerequisite_dict)
for pre_requisite_smu in missing_required_prerequisite_set:
result_list.append(pre_requisite_smu + '.' + smu_loader.file_suffix)
return result_list
def api_get_reload_list():
"""
Given a software package/SMU/SP list, return those
that require router reload.
"""
# The software packages/SMUs/SPs selected by the user to install
package_list = request.args.get('package_list').split()
rows = []
if not is_empty(package_list):
# Identify the platform and release
platform, release = SMUInfoLoader.get_platform_and_release(package_list)
if platform != UNKNOWN and release != UNKNOWN:
smu_loader = SMUInfoLoader(platform, release)
if smu_loader.is_valid:
for package_name in package_list:
if 'mini' in package_name:
rows.append({'entry': package_name, 'description': ''})
else:
# Strip the suffix
smu_info = smu_loader.get_smu_info(package_name.replace('.' + smu_loader.file_suffix, ''))
if smu_info is not None:
if "Reload" in smu_info.impact or "Reboot" in smu_info.impact:
rows.append({'entry': package_name, 'description': smu_info.description})
return jsonify(**{'data': rows})
def api_get_reload_list():
"""
Given a software package/SMU/SP list, return those
that require router reload.
"""
# The software packages/SMUs/SPs selected by the user to install
package_list = request.args.get('package_list').split()
rows = []
if not is_empty(package_list):
# Identify the platform and release
platform, release = SMUInfoLoader.get_platform_and_release(
package_list)
if platform != UNKNOWN and release != UNKNOWN:
smu_loader = SMUInfoLoader(platform, release)
if smu_loader.is_valid:
for package_name in package_list:
if 'mini' in package_name:
rows.append({'entry': package_name, 'description': ''})
else:
# Strip the suffix
smu_info = smu_loader.get_smu_info(
package_name.replace('.' + smu_loader.file_suffix,
''))
if smu_info is not None:
if "Reload" in smu_info.impact or "Reboot" in smu_info.impact:
rows.append({
'entry': package_name,
'description': smu_info.description
})
return jsonify(**{'data': rows})
def get_optimize_list(smu_list, include_annotation=True):
error_list = []
result_list = []
# Identify the platform and release
platform, release = get_platform_and_release(smu_list)
if platform == UNKNOWN or release == UNKNOWN:
return result_list, error_list
# Load the SMU information
smu_loader = SMUInfoLoader(platform, release)
file_suffix = smu_loader.file_suffix
smu_info_list= []
smu_name_set = set()
for line in smu_list:
smu_name = get_smu_lookup_name(line)
smu_info = smu_loader.get_smu_info(smu_name)
if smu_info is None:
error_list.append(smu_name)
continue
if smu_name in smu_name_set:
continue
smu_name_set.add(smu_name)
smu_info_list.append(smu_info)
if len(smu_info_list) > 0:
# Exclude all the superseded SMUs in smu_info_list
excluded_supersede_list = get_excluded_supersede_list(smu_info_list)
missing_required_prerequisite_dict = \
get_missing_required_prerequisites(smu_loader, excluded_supersede_list)
missing_required_prerequisite_set = get_unique_set_from_dict(missing_required_prerequisite_dict)
for pre_requisite_smu in missing_required_prerequisite_set:
if include_annotation:
result_list.append(pre_requisite_smu + '.' + file_suffix + ' (A Missing Pre-requisite)')
else:
result_list.append(pre_requisite_smu + '.' + file_suffix)
excluded_supersede_dict = get_dict_from_list(excluded_supersede_list)
for smu_info in smu_info_list:
if smu_info.name not in excluded_supersede_dict:
if include_annotation:
result_list.append(smu_info.name + '.' + file_suffix + ' (Superseded)')
else:
result_list.append(smu_info.name + '.' + file_suffix)
return result_list, error_list
def api_get_smu_info_by_name(platform, release, smu_name):
try:
smu_loader = SMUInfoLoader(platform, release)
smu_info = smu_loader.get_smu_info(smu_name)
except:
return ("Page does not exist; check platform and release", 404)
if smu_info is not None:
return jsonify(**{"data": get_smu_info(smu_info.id, platform, release)})
else:
return ("Page does not exist; check smu_name", 404)
def api_get_smu_info_by_name(platform, release, smu_name):
try:
smu_loader = SMUInfoLoader(platform, release)
smu_info = smu_loader.get_smu_info(smu_name)
except:
return ('Page does not exist; check platform and release', 404)
if smu_info is not None:
return jsonify(
**{'data': get_smu_info(smu_info.id, platform, release)})
else:
return ('Page does not exist; check smu_name', 404)
def api_get_sp_list(platform, release):
smu_loader = SMUInfoLoader(platform, release, from_cco=False)
if not smu_loader.is_valid:
return jsonify(**{'data': []})
hostname = request.args.get('hostname')
hide_installed_packages = request.args.get('hide_installed_packages')
if request.args.get('filter') == 'Optimal':
return get_smu_or_sp_list(hostname, hide_installed_packages,
smu_loader.get_optimal_sp_list(), smu_loader.file_suffix)
else:
return get_smu_or_sp_list(hostname, hide_installed_packages,
smu_loader.get_sp_list(), smu_loader.file_suffix)
def get_smu_info(smu_id, platform, release):
rows = []
smu_loader = SMUInfoLoader(platform, release)
smu_info = smu_loader.get_smu_info_by_id(smu_id)
if smu_info is not None:
row = {}
row["id"] = smu_info.id
row["name"] = smu_info.name
row["status"] = smu_info.status
row["type"] = smu_info.type
row["posted_date"] = smu_info.posted_date
row["ddts"] = smu_info.ddts
row["description"] = smu_info.description
row["functional_areas"] = smu_info.functional_areas
row["impact"] = smu_info.impact
row["package_bundles"] = smu_info.package_bundles
row["compressed_image_size"] = str(smu_info.compressed_image_size)
row["uncompressed_image_size"] = str(smu_info.uncompressed_image_size)
row["prerequisites"] = smu_info.prerequisites
row["supersedes"] = smu_info.supersedes
row["superseded_by"] = smu_info.superseded_by
row["composite_DDTS"] = smu_info.composite_DDTS
row["prerequisites_smu_ids"] = ""
row["supersedes_smu_ids"] = ""
row["superseded_by_smu_ids"] = ""
if smu_info.prerequisites != "":
prereqs = smu_info.prerequisites.split(",")
for smu in prereqs:
prereq = smu_loader.get_smu_info(smu)
row["prerequisites_smu_ids"] = row["prerequisites_smu_ids"] + prereq.id + ","
row["prerequisites_smu_ids"] = row["prerequisites_smu_ids"][:-1]
if smu_info.supersedes != "":
supersedes = smu_info.supersedes.split(",")
for smu in supersedes:
supersedes_info = smu_loader.get_smu_info(smu)
row["supersedes_smu_ids"] = row["supersedes_smu_ids"] + supersedes_info.id + ","
row["supersedes_smu_ids"] = row["supersedes_smu_ids"][:-1]
if smu_info.superseded_by != "":
superseded_by = smu_info.superseded_by.split(",")
for smu in superseded_by:
supersedes_info = smu_loader.get_smu_info(smu)
row["superseded_by_smu_ids"] = row["superseded_by_smu_ids"] + supersedes_info.id + ","
row["superseded_by_smu_ids"] = row["superseded_by_smu_ids"][:-1]
rows.append(row)
return rows
def get_optimize_list(smu_list):
error_list = []
result_list = []
# Identify the platform and release
platform, release = get_platform_and_release(smu_list)
if platform == UNKNOWN or release == UNKNOWN:
return result_list, error_list
# Load the SMU information
smu_loader = SMUInfoLoader(platform, release)
file_suffix = smu_loader.file_suffix
smu_info_list= []
smu_name_set = set()
for line in smu_list:
smu_name = get_smu_lookup_name(line)
smu_info = smu_loader.get_smu_info(smu_name)
if smu_info is None:
error_list.append(smu_name)
continue
if smu_name in smu_name_set:
continue
smu_name_set.add(smu_name)
smu_info_list.append(smu_info)
if len(smu_info_list) > 0:
# Exclude all the superseded SMUs in smu_info_list
excluded_supersede_list = get_excluded_supersede_list(smu_info_list)
missing_required_prerequisite_dict = \
get_missing_required_prerequisites(smu_loader, excluded_supersede_list)
missing_required_prerequisite_set = get_unique_set_from_dict(missing_required_prerequisite_dict)
for pre_requisite_smu in missing_required_prerequisite_set:
result_list.append(pre_requisite_smu + '.' + file_suffix + ' (A Missing Pre-requisite)')
excluded_supersede_dict = get_dict_from_list(excluded_supersede_list)
for smu_info in smu_info_list:
if smu_info.name not in excluded_supersede_dict:
result_list.append(smu_info.name + '.' + file_suffix + ' (Superseded)')
else:
result_list.append(smu_info.name + '.' + file_suffix)
return result_list, error_list
def create_download_jobs(db_session, platform, release, pending_downloads, server_id, server_directory, created_by):
"""
Pending downloads is an array of TAR files.
"""
smu_meta = db_session.query(SMUMeta).filter(SMUMeta.platform_release == platform + '_' + release).first()
if smu_meta is not None:
for cco_filename in pending_downloads:
# If the requested download_file is not in the download table, include it
if not is_pending_on_download(db_session, cco_filename, server_id, server_directory):
package_type = SMUInfoLoader.get_cco_file_package_type(db_session, cco_filename)
if package_type == PackageType.SERVICE_PACK:
software_type_id = smu_meta.sp_software_type_id
elif package_type == PackageType.SOFTWARE:
software_type_id = smu_meta.tar_software_type_id
elif package_type == PackageType.SMU:
software_type_id = smu_meta.smu_software_type_id
else:
# Best effort, it should not happen unless a SMU In-Transit is somehow get selected.
# All Posted software should have a cco file name entry.
software_type_id = smu_meta.smu_software_type_id
download_job = DownloadJob(
cco_filename=cco_filename,
pid=smu_meta.pid,
mdf_id=smu_meta.mdf_id,
software_type_id=software_type_id,
server_id=server_id,
server_directory=server_directory,
user_id=current_user.id,
created_by=created_by)
db_session.add(download_job)
db_session.commit()
def get_platforms_and_releases_dict(db_session):
excluded_platform_list = []
preferences = Preferences.get(db_session, current_user.id)
# It is possible that the preferences have not been created yet.
if preferences is not None and preferences.excluded_platforms_and_releases is not None:
excluded_platform_list = preferences.excluded_platforms_and_releases.split(
',')
rows = []
catalog = SMUInfoLoader.get_catalog()
if len(catalog) > 0:
for platform in catalog:
releases = catalog[platform]
for release in releases:
row = dict()
row['platform'] = platform
row['release'] = release
row['excluded'] = True if platform + '_' + release in excluded_platform_list else False
rows.append(row)
else:
# If get_catalog() failed, populate the excluded platforms and releases
for platform_and_release in excluded_platform_list:
pos = platform_and_release.rfind('_')
if pos > 0:
row = dict()
row['platform'] = platform_and_release[:pos]
row['release'] = platform_and_release[pos + 1:]
row['excluded'] = True
rows.append(row)
return rows
def api_get_sp_list(platform, release):
smu_loader = SMUInfoLoader(platform, release, from_cco=False)
if not smu_loader.is_valid:
return jsonify(**{'data': []})
hostname = request.args.get('hostname')
hide_installed_packages = request.args.get('hide_installed_packages')
if request.args.get('filter') == 'Optimal':
return get_smu_or_sp_list(hostname, hide_installed_packages,
smu_loader.get_optimal_sp_list(),
smu_loader.file_suffix)
else:
return get_smu_or_sp_list(hostname, hide_installed_packages,
smu_loader.get_sp_list(),
smu_loader.file_suffix)
def get_platforms_and_releases_dict(db_session):
excluded_platform_list = []
preferences = Preferences.get(db_session, current_user.id)
# It is possible that the preferences have not been created yet.
if preferences is not None and preferences.excluded_platforms_and_releases is not None:
excluded_platform_list = preferences.excluded_platforms_and_releases.split(',')
rows = []
catalog = SMUInfoLoader.get_catalog()
if len(catalog) > 0:
for platform in catalog:
releases = catalog[platform]
for release in releases:
row = dict()
row['platform'] = platform
row['release'] = release
row['excluded'] = True if platform + '_' + release in excluded_platform_list else False
rows.append(row)
else:
# If get_catalog() failed, populate the excluded platforms and releases
for platform_and_release in excluded_platform_list:
pos = platform_and_release.rfind('_')
if pos > 0:
row = dict()
row['platform'] = platform_and_release[:pos]
row['release'] = platform_and_release[pos+1:]
row['excluded'] = True
rows.append(row)
return rows
def api_get_tar_list(platform, release):
smu_loader = SMUInfoLoader(platform, release, from_cco=False)
if not smu_loader.is_valid:
return jsonify(**{'data': []})
else:
file_list = get_file_list(get_repository_directory(), '.tar')
tars_list = smu_loader.get_tar_list()
rows = []
for tar_info in tars_list:
row = dict()
row['ST'] = 'True' if tar_info.name in file_list else 'False'
row['name'] = tar_info.name
row['compressed_size'] = tar_info.compressed_image_size
row['description'] = ""
rows.append(row)
return jsonify(**{'data': rows})
def api_get_tar_list(platform, release):
smu_loader = SMUInfoLoader(platform, release, from_cco=False)
if not smu_loader.is_valid:
return jsonify(**{'data': []})
else:
file_list = get_file_list(get_repository_directory(), '.tar')
tars_list = smu_loader.get_tar_list()
rows = []
for tar_info in tars_list:
row = dict()
row['ST'] = 'True' if tar_info.name in file_list else 'False'
row['name'] = tar_info.name
row['compressed_size'] = tar_info.compressed_image_size
row['description'] = ""
rows.append(row)
return jsonify(**{'data': rows})
def get_download_info_dict(smu_list):
download_info_dict = {}
platform, release = get_platform_and_release(smu_list)
if platform == UNKNOWN or release == UNKNOWN:
return download_info_dict, None
# Load the SMU information
smu_loader = SMUInfoLoader(platform, release)
for smu_name in smu_list:
lookup_name = get_smu_lookup_name(smu_name)
smu_info = smu_loader.get_smu_info(lookup_name)
if smu_info is not None:
# Return back the same name (i.e. smu_name)
download_info_dict[smu_name] = smu_info.cco_filename
else:
download_info_dict[smu_name] = None
return download_info_dict, smu_loader
def get_smus_since(platform, release):
date = request.args.get("date")
date = datetime.datetime.strptime(date, "%m-%d-%Y")
try:
smu_loader = SMUInfoLoader(platform, release)
except:
return ("Page does not exist; check platform and release", 404)
rows = []
for smu_info in smu_loader.get_smu_list():
if datetime.datetime.strptime(smu_info.posted_date.split()[0], "%m/%d/%Y") >= date:
rows = rows + get_smu_info(smu_info.id, platform, release)
# Get the posted_date of each dictionary, split it at the first space so you get mm/dd/yyyy.
# Convert that string to a datetime, then sort the list of dictionaries by the posted_dates.
rows.sort(key=lambda k: datetime.datetime.strptime(k["posted_date"].split()[0], "%m/%d/%Y"), reverse=True)
return jsonify(**{"data": rows})
def get_download_info_dict(smu_list):
download_info_dict = {}
platform, release = get_platform_and_release(smu_list)
if platform == UNKNOWN or release == UNKNOWN:
return download_info_dict, None
# Load the SMU information
smu_loader = SMUInfoLoader(platform, release)
for smu_name in smu_list:
lookup_name = get_smu_lookup_name(smu_name)
smu_info = smu_loader.get_smu_info(lookup_name)
if smu_info is not None:
# Return back the same name (i.e. smu_name)
download_info_dict[smu_name] = smu_info.cco_filename
else:
download_info_dict[smu_name] = None
return download_info_dict, smu_loader
def api_get_smu_info_by_id(platform, release, smu_id):
try:
SMUInfoLoader(platform, release)
except:
return ('Page does not exist; check platform and release', 404)
data = get_smu_info(smu_id, platform, release)
if data:
return jsonify(**{'data': data})
else:
return ('Page does not exist; check smu_id', 404)
def api_get_cco_software(request):
"""
http://localhost:5000/api/v1/cco/software?platform=asr9k_px&release=5.3.3
"""
validate_url_parameters(request, ['platform', 'release', 'date'])
platform = request.args.get('platform')
release = request.args.get('release')
date = request.args.get('date')
if date:
date = datetime.datetime.strptime(date, "%m-%d-%Y")
else:
date = datetime.datetime.strptime('01-01-2000', "%m-%d-%Y")
optimal = request.args.get('optimal')
rows = []
smu_loader = SMUInfoLoader(platform, release)
if smu_loader.is_valid:
if optimal and optimal == 'false':
smu_list = smu_loader.get_smu_list()
sp_list = smu_loader.get_sp_list()
else:
smu_list = smu_loader.get_optimal_smu_list()
sp_list = smu_loader.get_optimal_sp_list()
for smu_info in smu_list:
if datetime.datetime.strptime(smu_info.posted_date.split()[0], "%m/%d/%Y") >= date:
rows.append(get_smu_info(smu_info))
for sp_info in sp_list:
if datetime.datetime.strptime(sp_info.posted_date.split()[0], "%m/%d/%Y") >= date:
rows.append(get_smu_info(sp_info))
if rows:
return jsonify(**{RESPONSE_ENVELOPE: {'software_list': rows}})
return failed_response(('Unable to get software information for platform {} ' +
'and release {}').format(platform, release))
def write_software_profile_info(self):
self.ws.write(self.row, 0, 'Software Profile: ' + self.conformance_report.software_profile, XLSWriter.style_bold)
self.row += 2
software_profile_packages = self.conformance_report.software_profile_packages.split(',')
smu_loader = None
platform, release = get_platform_and_release(software_profile_packages)
if platform != UNKNOWN and release != UNKNOWN:
smu_loader = SMUInfoLoader(platform, release)
for software_profile_package in software_profile_packages:
self.ws.write(self.row, 0, software_profile_package)
if smu_loader is not None and smu_loader.is_valid:
smu_info = smu_loader.get_smu_info(software_profile_package.replace('.' + smu_loader.file_suffix,''))
if smu_info is not None:
self.ws.write(self.row, 1, smu_info.description)
self.row += 1
self.row += 1
def api_get_cco_software_entry(request, name_or_id):
"""
http://localhost:5000/api/v1/cco/software/AA09694?platform=asr9k_px&release=5.3.3
name_or_id can be the PIMS ID (e.g., AA09694) or the software name (asr9k-p-4.2.3.CSCut30136)
"""
validate_url_parameters(request, ['platform', 'release'])
platform = request.args.get('platform')
release = request.args.get('release')
smu_loader = SMUInfoLoader(platform, release)
if smu_loader.is_valid:
smu_info = smu_loader.get_smu_info(name_or_id)
if smu_info:
return jsonify(**{RESPONSE_ENVELOPE: get_smu_info(smu_info)})
else:
# Now search for the ID instead of name
smu_info = smu_loader.get_smu_info_by_id(name_or_id)
if smu_info:
return jsonify(**{RESPONSE_ENVELOPE: get_smu_info(smu_info)})
return failed_response('Unable to locate {}'.format(name_or_id), return_code=HTTP_NOT_FOUND)
def get_smus_since(platform, release):
date = request.args.get('date')
date = datetime.datetime.strptime(date, "%m-%d-%Y")
try:
smu_loader = SMUInfoLoader(platform, release)
except:
return ('Page does not exist; check platform and release', 404)
rows = []
for smu_info in smu_loader.get_smu_list():
if datetime.datetime.strptime(smu_info.posted_date.split()[0],
"%m/%d/%Y") >= date:
rows = rows + get_smu_info(smu_info.id, platform, release)
# Get the posted_date of each dictionary, split it at the first space so you get mm/dd/yyyy.
# Convert that string to a datetime, then sort the list of dictionaries by the posted_dates.
rows.sort(key=lambda k: datetime.datetime.strptime(
k['posted_date'].split()[0], '%m/%d/%Y'),
reverse=True)
return jsonify(**{'data': rows})
def api_get_cco_software_entry(request, name_or_id):
"""
http://localhost:5000/api/v1/cco/software/AA09694?platform=asr9k_px&release=5.3.3
name_or_id can be the PIMS ID (e.g., AA09694) or the software name (asr9k-p-4.2.3.CSCut30136)
"""
validate_url_parameters(request, ['platform', 'release'])
platform = request.args.get('platform')
release = request.args.get('release')
smu_loader = SMUInfoLoader(platform, release)
if smu_loader.is_valid:
smu_info = smu_loader.get_smu_info(name_or_id)
if smu_info:
return jsonify(**{RESPONSE_ENVELOPE: get_smu_info(smu_info)})
else:
# Now search for the ID instead of name
smu_info = smu_loader.get_smu_info_by_id(name_or_id)
if smu_info:
return jsonify(**{RESPONSE_ENVELOPE: get_smu_info(smu_info)})
return failed_response('Unable to locate {}'.format(name_or_id),
return_code=HTTP_NOT_FOUND)
def get_download_info_dict(smu_list):
"""
Given a SMU list, return a dictionary which contains
key: smu name in smu_list
value: cco filename (can be None if smu_name is not in the XML file)
"""
download_info_dict = {}
platform, release = get_platform_and_release(smu_list)
if platform == UNKNOWN or release == UNKNOWN:
return download_info_dict, None
# Load the SMU information
smu_loader = SMUInfoLoader(platform, release)
for smu_name in smu_list:
lookup_name = get_smu_lookup_name(smu_name)
smu_info = smu_loader.get_smu_info(lookup_name)
if smu_info is not None:
# Return back the same name (i.e. smu_name)
download_info_dict[smu_name] = smu_info.cco_filename
else:
download_info_dict[smu_name] = None
return download_info_dict, smu_loader
def api_get_conformance_report_software_profile_packages(id):
rows = []
db_session = DBSession()
conformance_report = get_conformance_report_by_id(db_session, id)
if conformance_report is not None:
software_profile_packages = conformance_report.software_profile_packages.split(',')
smu_loader = None
platform, release = get_platform_and_release(software_profile_packages)
if platform != UNKNOWN and release != UNKNOWN:
smu_loader = SMUInfoLoader(platform, release)
for software_profile_package in software_profile_packages:
description = ''
if smu_loader is not None and smu_loader.is_valid:
smu_info = smu_loader.get_smu_info(software_profile_package.replace('.' + smu_loader.file_suffix,''))
if smu_info is not None:
description = smu_info.description
rows.append({'software_profile_package': software_profile_package,
'description': description})
return jsonify(**{'data': rows})
def get_download_info_dict(smu_list):
"""
Given a SMU list, return a dictionary which contains
key: smu name in smu_list
value: cco filename (can be None if smu_name is not in the XML file)
"""
download_info_dict = {}
platform, release = get_platform_and_release(smu_list)
if platform == UNKNOWN or release == UNKNOWN:
return download_info_dict, None
# Load the SMU information
smu_loader = SMUInfoLoader(platform, release)
for smu_name in smu_list:
lookup_name = get_smu_lookup_name(smu_name)
smu_info = smu_loader.get_smu_info(lookup_name)
if smu_info is not None:
# Return back the same name (i.e. smu_name)
download_info_dict[smu_name] = smu_info.cco_filename
else:
download_info_dict[smu_name] = None
return download_info_dict, smu_loader
def api_create_download_jobs():
try:
server_id = request.form.get("server_id")
server_directory = request.form.get("server_directory")
smu_list = request.form.get("smu_list").split()
pending_downloads = request.form.get("pending_downloads").split()
# Derives the platform and release using the first SMU name.
if len(smu_list) > 0 and len(pending_downloads) > 0:
platform, release = SMUInfoLoader.get_platform_and_release(smu_list)
create_download_jobs(DBSession(), platform, release, pending_downloads, server_id, server_directory, current_user.username)
return jsonify({'status': 'OK'})
except:
logger.exception('api_create_download_jobs() hit exception')
return jsonify({'status': 'Failed'})
def api_get_csm_message():
rows = []
username = request.form['username']
password = request.form['password']
db_session = DBSession()
user, authenticated = \
User.authenticate(db_session.query, username, password)
if authenticated:
# if user.privilege == UserPrivilege.ADMIN:
csm_messages = SMUInfoLoader.get_cco_csm_messages()
if len(csm_messages) > 0:
acknowledgment_date = datetime.datetime(2000, 1, 1)
if len(user.csm_message) > 0:
acknowledgment_date = user.csm_message[0].acknowledgment_date
# csm_messages returns a dictionary keyed by a token (e.g. @12/01/01@Admin,Operator) and message
readers = [
UserPrivilege.ADMIN, UserPrivilege.NETWORK_ADMIN,
UserPrivilege.OPERATOR, UserPrivilege.VIEWER
]
for csm_message in csm_messages:
tokens = csm_message['token'].split('@')
date = tokens[0]
if len(tokens) == 2:
readers = tokens[1].split(',')
if user.privilege in readers:
message = csm_message['message']
try:
delta = datetime.datetime.strptime(
date, "%Y/%m/%d") - acknowledgment_date
if delta.days > 0:
rows.append({
'date':
date,
'message':
message.replace("\n", "<br>")
})
except:
logger.exception('api_get_csm_message() hit exception')
return jsonify(**{'data': rows})
def get_smu_info(smu_id, platform, release):
rows = []
smu_loader = SMUInfoLoader(platform, release)
smu_info = smu_loader.get_smu_info_by_id(smu_id)
if smu_info is not None:
row = {}
row['id'] = smu_info.id
row['name'] = smu_info.name
row['status'] = smu_info.status
row['type'] = smu_info.type
row['posted_date'] = smu_info.posted_date
row['ddts'] = smu_info.ddts
row['description'] = smu_info.description
row['functional_areas'] = smu_info.functional_areas
row['impact'] = smu_info.impact
row['package_bundles'] = smu_info.package_bundles
row['compressed_image_size'] = str(smu_info.compressed_image_size)
row['uncompressed_image_size'] = str(smu_info.uncompressed_image_size)
row['prerequisites'] = smu_info.prerequisites
row['supersedes'] = smu_info.supersedes
row['superseded_by'] = smu_info.superseded_by
row['composite_DDTS'] = smu_info.composite_DDTS
row['prerequisites_smu_ids'] = ""
row['supersedes_smu_ids'] = ""
row['superseded_by_smu_ids'] = ""
if smu_info.prerequisites != "":
prereqs = smu_info.prerequisites.split(',')
for smu in prereqs:
prereq = smu_loader.get_smu_info(smu)
row['prerequisites_smu_ids'] = row[
'prerequisites_smu_ids'] + prereq.id + ','
row['prerequisites_smu_ids'] = row['prerequisites_smu_ids'][:-1]
if smu_info.supersedes != "":
supersedes = smu_info.supersedes.split(',')
for smu in supersedes:
supersedes_info = smu_loader.get_smu_info(smu)
row['supersedes_smu_ids'] = row[
'supersedes_smu_ids'] + supersedes_info.id + ','
row['supersedes_smu_ids'] = row['supersedes_smu_ids'][:-1]
if smu_info.superseded_by != "":
superseded_by = smu_info.superseded_by.split(',')
for smu in superseded_by:
supersedes_info = smu_loader.get_smu_info(smu)
row['superseded_by_smu_ids'] = row[
'superseded_by_smu_ids'] + supersedes_info.id + ','
row['superseded_by_smu_ids'] = row['superseded_by_smu_ids'][:-1]
rows.append(row)
return rows
def api_create_download_jobs():
try:
server_id = request.form.get("server_id")
server_directory = request.form.get("server_directory")
smu_list = request.form.get("smu_list").split()
pending_downloads = request.form.get("pending_downloads").split()
# Derives the platform and release using the first SMU name.
if len(smu_list) > 0 and len(pending_downloads) > 0:
platform, release = SMUInfoLoader.get_platform_and_release(
smu_list)
create_download_jobs(DBSession(), platform, release,
pending_downloads, server_id,
server_directory, current_user.username)
return jsonify({'status': 'OK'})
except:
logger.exception('api_create_download_jobs() hit exception')
return jsonify({'status': 'Failed'})
def api_get_catalog():
db_session = DBSession()
excluded_platform_list = []
preferences = Preferences.get(db_session, current_user.id)
if preferences.excluded_platforms_and_releases is not None:
excluded_platform_list = preferences.excluded_platforms_and_releases.split(',')
rows = []
catalog = SMUInfoLoader.get_catalog()
for platform in catalog:
releases = get_filtered_platform_list(platform, catalog[platform], excluded_platform_list)
if len(releases) > 0:
row = dict()
row['platform'] = platform
row['beautified_platform'] = beautify_platform(platform)
row['releases'] = releases
rows.append(row)
return jsonify(**{'data': rows})
def api_get_catalog():
db_session = DBSession()
excluded_platform_list = []
preferences = Preferences.get(db_session, current_user.id)
if preferences.excluded_platforms_and_releases is not None:
excluded_platform_list = preferences.excluded_platforms_and_releases.split(
',')
rows = []
catalog = SMUInfoLoader.get_catalog()
for platform in catalog:
releases = get_filtered_platform_list(platform, catalog[platform],
excluded_platform_list)
if len(releases) > 0:
row = dict()
row['platform'] = platform
row['beautified_platform'] = beautify_platform(platform)
row['releases'] = releases
rows.append(row)
return jsonify(**{'data': rows})
def api_get_csm_message():
rows = []
username = request.form['username']
password = request.form['password']
db_session = DBSession()
user, authenticated = \
User.authenticate(db_session.query, username, password)
if authenticated:
# if user.privilege == UserPrivilege.ADMIN:
csm_messages = SMUInfoLoader.get_cco_csm_messages()
if len(csm_messages) > 0:
acknowledgment_date = datetime.datetime(2000, 1, 1)
if len(user.csm_message) > 0:
acknowledgment_date = user.csm_message[0].acknowledgment_date
# csm_messages returns a dictionary keyed by a token (e.g. @12/01/01@Admin,Operator) and message
readers = [ UserPrivilege.ADMIN, UserPrivilege.NETWORK_ADMIN, UserPrivilege.OPERATOR, UserPrivilege.VIEWER]
for csm_message in csm_messages:
tokens = csm_message['token'].split('@')
date = tokens[0]
if len(tokens) == 2:
readers = tokens[1].split(',')
if user.privilege in readers:
message = csm_message['message']
try:
delta = datetime.datetime.strptime(date, "%Y/%m/%d") - acknowledgment_date
if delta.days > 0:
rows.append({'date': date, 'message': message.replace("\n", "<br>")})
except:
logger.exception('api_get_csm_message() hit exception')
return jsonify(**{'data': rows})
def create_download_jobs(db_session, platform, release, pending_downloads,
server_id, server_directory, created_by):
"""
Pending downloads is an array of TAR files.
"""
smu_meta = db_session.query(SMUMeta).filter(
SMUMeta.platform_release == platform + '_' + release).first()
if smu_meta is not None:
for cco_filename in pending_downloads:
# If the requested download_file is not in the download table, include it
if not is_pending_on_download(db_session, cco_filename, server_id,
server_directory):
package_type = SMUInfoLoader.get_cco_file_package_type(
db_session, cco_filename)
if package_type == PackageType.SERVICE_PACK:
software_type_id = smu_meta.sp_software_type_id
elif package_type == PackageType.SOFTWARE:
software_type_id = smu_meta.tar_software_type_id
elif package_type == PackageType.SMU:
software_type_id = smu_meta.smu_software_type_id
else:
# Best effort, it should not happen unless a SMU In-Transit is somehow get selected.
# All Posted software should have a cco file name entry.
software_type_id = smu_meta.smu_software_type_id
download_job = DownloadJob(cco_filename=cco_filename,
pid=smu_meta.pid,
mdf_id=smu_meta.mdf_id,
software_type_id=software_type_id,
server_id=server_id,
server_directory=server_directory,
user_id=current_user.id,
created_by=created_by)
db_session.add(download_job)
db_session.commit()
def api_get_cco_software(request):
"""
http://localhost:5000/api/v1/cco/software?platform=asr9k_px&release=5.3.3
"""
validate_url_parameters(request, ['platform', 'release', 'date'])
platform = request.args.get('platform')
release = request.args.get('release')
date = request.args.get('date')
if date:
date = datetime.datetime.strptime(date, "%m-%d-%Y")
else:
date = datetime.datetime.strptime('01-01-2000', "%m-%d-%Y")
optimal = request.args.get('optimal')
rows = []
smu_loader = SMUInfoLoader(platform, release)
if smu_loader.is_valid:
if optimal and optimal == 'false':
smu_list = smu_loader.get_smu_list()
sp_list = smu_loader.get_sp_list()
else:
smu_list = smu_loader.get_optimal_smu_list()
sp_list = smu_loader.get_optimal_sp_list()
for smu_info in smu_list:
if datetime.datetime.strptime(smu_info.posted_date.split()[0],
"%m/%d/%Y") >= date:
rows.append(get_smu_info(smu_info))
for sp_info in sp_list:
if datetime.datetime.strptime(sp_info.posted_date.split()[0],
"%m/%d/%Y") >= date:
rows.append(get_smu_info(sp_info))
if rows:
return jsonify(**{RESPONSE_ENVELOPE: {'software_list': rows}})
return failed_response(
('Unable to get software information for platform {} ' +
'and release {}').format(platform, release))
def export_software_information(platform, release):
smu_loader = SMUInfoLoader(platform, release)
if not smu_loader.is_valid:
return jsonify({'status': 'Failed'})
export_format = request.args.get('export_format')
export_layout = request.args.get('export_layout')
export_filter = request.args.get('filter')
if export_filter == 'Optimal':
smu_list = smu_loader.get_optimal_smu_list()
sp_list = smu_loader.get_optimal_sp_list()
else:
smu_list = smu_loader.get_smu_list()
sp_list = smu_loader.get_sp_list()
if export_format == ExportInformationFormat.HTML:
if export_layout == ExportSoftwareInformationLayout.CONCISE:
writer = ExportSoftwareInfoHTMLConciseWriter(user=current_user,
smu_loader=smu_loader,
smu_list=smu_list,
sp_list=sp_list)
else:
writer = ExportSoftwareInfoHTMLDefaultWriter(user=current_user,
smu_loader=smu_loader,
smu_list=smu_list,
sp_list=sp_list)
else:
if export_layout == ExportSoftwareInformationLayout.CONCISE:
writer = ExportSoftwareInfoExcelConciseWriter(
user=current_user,
smu_loader=smu_loader,
smu_list=smu_list,
sp_list=sp_list)
else:
writer = ExportSoftwareInfoExcelDefaultWriter(
user=current_user,
smu_loader=smu_loader,
smu_list=smu_list,
sp_list=sp_list)
return send_file(writer.write_report(), as_attachment=True)
def api_get_cco_catalog():
"""
http://localhost:5000/api/v1/cco/catalog
"""
return jsonify(**{RESPONSE_ENVELOPE: SMUInfoLoader.get_catalog()})
def get_validated_list(smu_list):
"""
Returns the validated list given the SMU/SP list.
A smu_list may contain packages, SMUs, SPs, or junk texts.
"""
unrecognized_list = []
package_list = []
result_list = []
# Identify the platform and release
platform, release = get_platform_and_release(smu_list)
if platform == UNKNOWN or release == UNKNOWN:
for line in smu_list:
result_list.append({'smu_entry': line, 'is': 'Unrecognized', 'description': ''})
return result_list
# Load the SMU information
smu_loader = SMUInfoLoader(platform, release)
file_suffix = smu_loader.file_suffix
smu_info_list= []
smu_name_set = set()
for line in smu_list:
smu_name = get_smu_lookup_name(line)
smu_info = smu_loader.get_smu_info(smu_name)
if smu_info is None:
# Check if the entry is a package type
if get_platform(smu_name) == UNKNOWN:
unrecognized_list.append(smu_name)
else:
package_list.append(smu_name)
continue
if smu_name in smu_name_set:
continue
smu_name_set.add(smu_name)
smu_info_list.append(smu_info)
if len(smu_info_list) > 0:
# Exclude all the superseded SMUs in smu_info_list
excluded_supersede_list = get_excluded_supersede_list(smu_info_list)
missing_required_prerequisite_dict = \
get_missing_required_prerequisites(smu_loader, excluded_supersede_list)
missing_required_prerequisite_set = get_unique_set_from_dict(missing_required_prerequisite_dict)
for pre_requisite_smu in missing_required_prerequisite_set:
pre_requisite_smu_info = smu_loader.get_smu_info(pre_requisite_smu)
description = pre_requisite_smu_info.description if pre_requisite_smu_info is not None else ''
result_list.append({'smu_entry': pre_requisite_smu + '.' + file_suffix,
'is': 'Pre-requisite', 'description':description})
excluded_supersede_dict = get_dict_from_list(excluded_supersede_list)
for smu_info in smu_info_list:
if smu_info.name not in excluded_supersede_dict:
result_list.append({'smu_entry': smu_info.name + '.' + file_suffix,
'is': 'Superseded', 'description': smu_info.description})
else:
result_list.append({'smu_entry': smu_info.name + '.' + file_suffix,
'is': 'SMU/SP', 'description': smu_info.description})
if len(package_list) > 0:
for entry in package_list:
result_list.append({'smu_entry': entry, 'is': 'Package', 'description': ''})
if len(unrecognized_list) > 0:
for entry in unrecognized_list:
result_list.append({'smu_entry': entry, 'is': 'Unrecognized', 'description': ''})
return result_list
def api_refresh_all_smu_info():
if SMUInfoLoader.refresh_all():
return jsonify({'status': 'OK'})
else:
return jsonify({'status': 'Failed'})
def api_refresh_all_smu_info():
if SMUInfoLoader.refresh_all():
return jsonify({'status': 'OK'})
else:
return jsonify({'status': 'Failed'})
def get_validated_list(smu_list):
"""
Returns the validated list given the SMU/SP list.
A smu_list may contain packages, SMUs, SPs, or junk texts.
"""
unrecognized_list = []
package_list = []
result_list = []
# Identify the platform and release
platform, release = get_platform_and_release(smu_list)
if platform == UNKNOWN or release == UNKNOWN:
for line in smu_list:
result_list.append({'smu_entry': line, 'is': 'Unrecognized'})
return result_list
# Load the SMU information
smu_loader = SMUInfoLoader(platform, release)
file_suffix = smu_loader.file_suffix
smu_info_list = []
smu_name_set = set()
for line in smu_list:
smu_name = get_smu_lookup_name(line)
smu_info = smu_loader.get_smu_info(smu_name)
if smu_info is None:
# Check if the entry is a package type
if get_platform(smu_name) == UNKNOWN:
unrecognized_list.append(smu_name)
else:
package_list.append(smu_name)
continue
if smu_name in smu_name_set:
continue
smu_name_set.add(smu_name)
smu_info_list.append(smu_info)
if len(smu_info_list) > 0:
# Exclude all the superseded SMUs in smu_info_list
excluded_supersede_list = get_excluded_supersede_list(smu_info_list)
missing_required_prerequisite_dict = \
get_missing_required_prerequisites(smu_loader, excluded_supersede_list)
missing_required_prerequisite_set = get_unique_set_from_dict(
missing_required_prerequisite_dict)
for pre_requisite_smu in missing_required_prerequisite_set:
pre_requisite_smu_info = smu_loader.get_smu_info(pre_requisite_smu)
description = pre_requisite_smu_info.description if pre_requisite_smu_info is not None else ''
result_list.append({
'smu_entry': pre_requisite_smu + '.' + file_suffix,
'is': 'Pre-requisite',
'description': description
})
excluded_supersede_dict = get_dict_from_list(excluded_supersede_list)
for smu_info in smu_info_list:
if smu_info.name not in excluded_supersede_dict:
result_list.append({
'smu_entry': smu_info.name + '.' + file_suffix,
'is': 'Superseded',
'description': smu_info.description
})
else:
result_list.append({
'smu_entry': smu_info.name + '.' + file_suffix,
'is': 'SMU/SP',
'description': smu_info.description
})
if len(package_list) > 0:
for entry in package_list:
result_list.append({
'smu_entry': entry,
'is': 'Package',
'description': ''
})
if len(unrecognized_list) > 0:
for entry in unrecognized_list:
result_list.append({
'smu_entry': entry,
'is': 'Unrecognized',
'description': ''
})
return result_list
def get_software_catalog():
return jsonify(**{"data": SMUInfoLoader.get_catalog()})
def get_software_catalog():
return jsonify(**{'data': SMUInfoLoader.get_catalog()})
def create_or_update_install_job(db_session,
host_id,
install_action,
scheduled_time,
software_packages=[],
server_id=-1,
server_directory='',
custom_command_profile_ids=[],
dependency=0,
pending_downloads=[],
created_by=None,
install_job=None):
if not type(software_packages) is list:
raise ValueError('software_packages must be a list type')
if not type(custom_command_profile_ids) is list:
raise ValueError('custom_command_profile_ids must be a list type')
if not type(pending_downloads) is list:
raise ValueError('pending_downloads must be a list type')
# This is a new install_job
if install_job is None:
install_job = InstallJob()
install_job.host_id = host_id
db_session.add(install_job)
install_job.install_action = install_action
if install_job.install_action == InstallAction.INSTALL_ADD and not is_empty(
pending_downloads):
install_job.pending_downloads = ','.join(pending_downloads)
else:
install_job.pending_downloads = ''
install_job.scheduled_time = get_datetime(scheduled_time)
# Only Install Add and Pre-Migrate should have server_id and server_directory
if install_action == InstallAction.INSTALL_ADD or install_action == InstallAction.PRE_MIGRATE:
install_job.server_id = int(server_id) if int(server_id) > 0 else None
install_job.server_directory = server_directory
else:
install_job.server_id = None
install_job.server_directory = ''
install_job_packages = []
# Only the following install actions should have software packages
if install_action == InstallAction.INSTALL_ADD or \
install_action == InstallAction.INSTALL_ACTIVATE or \
install_action == InstallAction.INSTALL_REMOVE or \
install_action == InstallAction.INSTALL_DEACTIVATE or \
install_action == InstallAction.PRE_MIGRATE:
for software_package in software_packages:
if install_action == InstallAction.INSTALL_ADD:
if is_file_acceptable_for_install_add(software_package):
install_job_packages.append(software_package)
else:
# Install Activate can have external or internal package names
install_job_packages.append(software_package)
install_job.packages = ','.join(install_job_packages)
install_job.dependency = dependency if dependency > 0 else None
user = get_user(db_session, created_by)
install_job.created_by = created_by
install_job.user_id = None if user is None else user.id
if install_action == InstallAction.PRE_UPGRADE or install_action == InstallAction.POST_UPGRADE or \
install_action == InstallAction.PRE_MIGRATE or install_action == InstallAction.MIGRATE_SYSTEM or \
install_action == InstallAction.POST_MIGRATE:
install_job.custom_command_profile_ids = ','.join(
custom_command_profile_ids) if custom_command_profile_ids else None
# Resets the following fields
install_job.status = None
install_job.status_time = None
install_job.session_log = None
install_job.trace = None
if install_job.install_action != InstallAction.UNKNOWN:
db_session.commit()
# Creates download jobs if needed
if install_job.install_action == InstallAction.INSTALL_ADD and \
len(install_job.packages) > 0 and \
len(install_job.pending_downloads) > 0:
# Use the SMU name to derive the platform and release strings
smu_list = install_job.packages.split(',')
pending_downloads = install_job.pending_downloads.split(',')
# Derives the platform and release using the first SMU name.
platform, release = SMUInfoLoader.get_platform_and_release(smu_list)
create_download_jobs(db_session, platform, release, pending_downloads,
install_job.server_id,
install_job.server_directory, created_by)
return install_job
def create_or_update_install_job(db_session, host_id, install_action, scheduled_time, software_packages=[],
server_id=-1, server_directory='', custom_command_profile_ids=[], dependency=0,
pending_downloads=[], created_by=None, install_job=None):
if not type(software_packages) is list:
raise ValueError('software_packages must be a list type')
if not type(custom_command_profile_ids) is list:
raise ValueError('custom_command_profile_ids must be a list type')
if not type(pending_downloads) is list:
raise ValueError('pending_downloads must be a list type')
# This is a new install_job
if install_job is None:
install_job = InstallJob()
install_job.host_id = host_id
db_session.add(install_job)
install_job.install_action = install_action
if install_job.install_action == InstallAction.INSTALL_ADD and not is_empty(pending_downloads):
install_job.pending_downloads = ','.join(pending_downloads)
else:
install_job.pending_downloads = ''
install_job.scheduled_time = get_datetime(scheduled_time)
# Only Install Add and Pre-Migrate should have server_id and server_directory
if install_action == InstallAction.INSTALL_ADD or install_action == InstallAction.PRE_MIGRATE:
install_job.server_id = int(server_id) if int(server_id) > 0 else None
install_job.server_directory = server_directory
else:
install_job.server_id = None
install_job.server_directory = ''
install_job_packages = []
# Only the following install actions should have software packages
if install_action == InstallAction.INSTALL_ADD or \
install_action == InstallAction.INSTALL_ACTIVATE or \
install_action == InstallAction.INSTALL_REMOVE or \
install_action == InstallAction.INSTALL_DEACTIVATE or \
install_action == InstallAction.PRE_MIGRATE:
for software_package in software_packages:
if install_action == InstallAction.INSTALL_ADD:
if is_file_acceptable_for_install_add(software_package):
install_job_packages.append(software_package)
else:
# Install Activate can have external or internal package names
install_job_packages.append(software_package)
install_job.packages = ','.join(install_job_packages)
install_job.dependency = dependency if dependency > 0 else None
user = get_user(db_session, created_by)
install_job.created_by = created_by
install_job.user_id = None if user is None else user.id
if install_action == InstallAction.PRE_UPGRADE or install_action == InstallAction.POST_UPGRADE or \
install_action == InstallAction.PRE_MIGRATE or install_action == InstallAction.MIGRATE_SYSTEM or \
install_action == InstallAction.POST_MIGRATE:
install_job.custom_command_profile_ids = ','.join(custom_command_profile_ids) if custom_command_profile_ids else None
# Resets the following fields
install_job.status = None
install_job.status_time = None
install_job.session_log = None
install_job.trace = None
if install_job.install_action != InstallAction.UNKNOWN:
db_session.commit()
# Creates download jobs if needed
if install_job.install_action == InstallAction.INSTALL_ADD and \
len(install_job.packages) > 0 and \
len(install_job.pending_downloads) > 0:
# Use the SMU name to derive the platform and release strings
smu_list = install_job.packages.split(',')
pending_downloads = install_job.pending_downloads.split(',')
# Derives the platform and release using the first SMU name.
platform, release = SMUInfoLoader.get_platform_and_release(smu_list)
create_download_jobs(db_session, platform, release, pending_downloads,
install_job.server_id, install_job.server_directory, created_by)
return install_job
def api_fetch_cco_software(platform, release):
smu_loader = SMUInfoLoader(platform, release)
return jsonify({'status': 'OK' if smu_loader.is_valid else 'Failed'})
def api_get_cco_catalog():
"""
http://localhost:5000/api/v1/cco/catalog
"""
return jsonify(**{RESPONSE_ENVELOPE: SMUInfoLoader.get_catalog()})
