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 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 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 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 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 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 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 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'})