def post_dependency_monkey_python( input: Dict[str, Any], seed: Optional[int] = None, dry_run: bool = False, decision: Optional[str] = None, debug: bool = False, count: Optional[int] = None, limit_latest_versions: Optional[int] = None, ): """Run dependency monkey on the given application stack to produce all the possible software stacks.""" parameters = { "requirements": input.pop("requirements"), "context": input.pop("context"), "pipeline": input.pop("pipeline", None), "predictor": input.pop("predictor", None), "predictor_config": input.pop("predictor_config", None), "runtime_environment": input.pop("runtime_environment", None), "job_id": OpenShift.generate_id("dependency-monkey"), "seed": seed, "dry_run": dry_run, "decision": decision, "debug": debug, "count": count, "limit_latest_versions": limit_latest_versions, } store = DependencyMonkeyRequestsStore() store.connect() store.store_request(parameters["job_id"], parameters) # These parts are reused from the stored request and are not sent via messages. parameters.pop("requirements") parameters.pop("context") parameters.pop("pipeline") parameters.pop("runtime_environment") return _do_schedule( parameters, _OPENSHIFT.schedule_dependency_monkey, stack_output=Configuration.THOTH_DEPENDENCY_MONKEY_STACK_OUTPUT, )
def post_build( build_detail: typing.Dict[str, typing.Any], *, base_registry_password: typing.Optional[str] = None, base_registry_user: typing.Optional[str] = None, base_registry_verify_tls: bool = True, output_registry_password: typing.Optional[str] = None, output_registry_user: typing.Optional[str] = None, output_registry_verify_tls: bool = True, debug: bool = False, environment_type: typing.Optional[str] = None, force: bool = False, origin: typing.Optional[str] = None, ) -> typing.Tuple[typing.Dict[str, typing.Any], int]: """Run analysis on a build.""" output_image = build_detail.get("output_image") base_image = build_detail.get("base_image") build_log = build_detail.get("build_log") if not output_image and not base_image and not build_log: return {"error": "No base, output nor build log provided"}, 400 buildlog_analysis_id = None buildlog_document_id = None if build_log: buildlog_document_id, buildlog_analysis_id = _store_build_log( build_log, force=force) message_parameters = { "base_image_analysis_id": None, # Assigned below. "base_image": base_image, "base_registry_password": base_registry_password, "base_registry_user": base_registry_user, "base_registry_verify_tls": base_registry_verify_tls, "output_image_analysis_id": None, # Assigned below. "output_image": output_image, "output_registry_password": output_registry_password, "output_registry_user": output_registry_user, "output_registry_verify_tls": output_registry_verify_tls, "environment_type": environment_type, "buildlog_document_id": buildlog_document_id, "buildlog_parser_id": None if buildlog_analysis_id else OpenShift.generate_id("buildlog-parser"), "origin": origin, "debug": debug, "job_id": OpenShift.generate_id("build-analysis"), } cache = AnalysesCacheStore() cache.connect() # Handle the base container image used during the build process. base_image_analysis = None base_image_analysis_id = None base_cached_document_id = None base_image_analysis_cached = False if base_image: base_image_info = { "image": base_image, "registry_user": base_registry_user, "registry_password": base_registry_password, "verify_tls": base_registry_verify_tls, } metadata_req = _do_get_image_metadata(**base_image_info) if metadata_req[1] != 200: # There was an error extracting metadata, tuple holds dictionary with error report and HTTP status code. return metadata_req base_image_metadata = metadata_req[0] # We compute digest of parameters so we do not reveal any authentication specific info. parameters_digest = _compute_digest_params(base_image) base_cached_document_id = base_image_metadata[ "digest"] + "+" + parameters_digest base_image_analysis_id = OpenShift.generate_id("package-extract") if not force: try: base_image_analysis_id = cache.retrieve_document_record( base_cached_document_id).pop("analysis_id") base_image_analysis_cached = True except CacheMiss: pass base_image_analysis = { "analysis_id": base_image_analysis_id, "cached": base_image_analysis_cached, "parameters": { "base_image": base_image, # "registry_password": base_registry_password, # "registry_user": base_registry_user, "registry_verify_tls": base_registry_verify_tls, }, } analysis_by_digest_store = AnalysisByDigest() analysis_by_digest_store.connect() analysis_by_digest_store.store_document(base_image_metadata["digest"], base_image_analysis) # Handle output ("resulting") container image used during the build process. output_image_analysis = None output_image_analysis_id = None output_cached_document_id = None output_image_analysis_cached = False if output_image: output_image_info = { "image": output_image, "registry_user": output_registry_user, "registry_password": output_registry_password, "verify_tls": output_registry_verify_tls, } metadata_req = _do_get_image_metadata(**output_image_info) if metadata_req[1] != 200: # There was an error extracting metadata, tuple holds dictionary with error report and HTTP status code. return metadata_req output_image_metadata = metadata_req[0] # We compute digest of parameters so we do not reveal any authentication specific info. parameters_digest = _compute_digest_params(output_image) output_cached_document_id = output_image_metadata[ "digest"] + "+" + parameters_digest output_image_analysis_id = OpenShift.generate_id("package-extract") if not force: try: output_image_analysis_id = cache.retrieve_document_record( output_cached_document_id).pop("analysis_id") output_image_analysis_cached = True except CacheMiss: pass output_image_analysis = { "analysis_id": output_image_analysis_id, "cached": output_image_analysis_cached, "parameters": { "output_image": output_image, # "registry_password": output_registry_password, # "registry_user": output_registry_user, "registry_verify_tls": output_registry_verify_tls, }, } analysis_by_digest_store = AnalysisByDigest() analysis_by_digest_store.connect() analysis_by_digest_store.store_document( output_image_metadata["digest"], output_image_analysis) message_parameters[ "base_image_analysis_id"] = base_image_analysis_id if not base_image_analysis_cached else None message_parameters["output_image_analysis_id"] = ( output_image_analysis_id if not output_image_analysis_cached else None) if build_log: pass response, status = _send_schedule_message(message_parameters, build_analysis_trigger_message, BuildAnalysisTriggerContent) if status != 202: # We do not return response directly as it holds data flattened and to make sure secrets are propagated back. return response, status # Store all the ids to caches once the message is sent so subsequent calls work as expected. if base_cached_document_id: cache.store_document_record(base_cached_document_id, {"analysis_id": base_image_analysis_id}) if output_cached_document_id: cache.store_document_record(output_cached_document_id, {"analysis_id": output_image_analysis_id}) if build_log and not buildlog_analysis_id: buildlogs_cache = BuildLogsAnalysesCacheStore() buildlogs_cache.connect() cached_document_id = _compute_digest_params(build_log) buildlogs_cache.store_document_record( cached_document_id, {"analysis_id": message_parameters["buildlog_parser_id"]}) if base_image_analysis or output_image_analysis: store = AnalysisResultsStore() store.connect() if base_image_analysis_id: store.store_request(base_image_analysis_id, base_image_analysis) if output_image_analysis: store.store_request(output_image_analysis_id, output_image_analysis) return { "base_image_analysis": base_image_analysis, "output_image_analysis": output_image_analysis, "buildlog_analysis": { "analysis_id": buildlog_analysis_id or message_parameters["buildlog_parser_id"], "cached": buildlog_analysis_id is not None, }, "buildlog_document_id": buildlog_document_id, }, 202