fosslight-binary 5.1.32__tar.gz → 5.1.34__tar.gz

{fosslight_binary-5.1.32 → fosslight_binary-5.1.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fosslight_binary
-Version: 5.1.32
+Version: 5.1.34
 Summary: FOSSLight Binary Scanner
 Author: LG Electronics
 License-Expression: Apache-2.0

{fosslight_binary-5.1.32 → fosslight_binary-5.1.34}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fosslight_binary"
-version = "5.1.32"
+version = "5.1.34"
 description = "FOSSLight Binary Scanner"
 readme = "README.md"
 license = "Apache-2.0"

{fosslight_binary-5.1.32 → fosslight_binary-5.1.34}/src/fosslight_binary/_jar_analysis.py

@@ -19,21 +19,38 @@ from fosslight_util.oss_item import OssItem
 
 logger = logging.getLogger(constant.LOGGER_NAME)
 
-# Both hosts serve the same Central Solr index and the same g/a/v fields, but
-# search.maven.org answers only about one query in six: the TCP connect always
-# succeeds and then the response never starts, so no timeout budget rescues it.
-# The Portal host answers every query in about half a second, so it goes first.
-_CENTRAL_SEARCH_URLS = (
-    "https://central.sonatype.com/solrsearch/select",
-    "https://search.maven.org/solrsearch/select",
-)
-_REQUEST_TIMEOUT = 10          # seconds - used for HEAD / POM download
-_CENTRAL_SEARCH_TIMEOUT = 2.5  # seconds - per-host budget, retried on timeout
+# The Central Portal host serves the Central Solr index and its g/a/v fields, so
+# its answer is authoritative for the whole index. The legacy search.maven.org
+# endpoint is no longer queried: it often accepts the TCP connect and then never
+# starts the response, so querying it only spends the timeout budget.
+_CENTRAL_SEARCH_URL = "https://central.sonatype.com/solrsearch/select"
+
+# (connect, read) seconds for the remote POM fetch. A dead host fails on connect
+# in 3s, while a POM that is merely slow still has 7s to arrive - the license is
+# taken from whatever answers, and the fallback behind it is final. Kept separate
+# from the search budget below: that one is deliberately tight to abandon a
+# stalled Solr host, which is the wrong bound for downloading a file.
+_POM_DOWNLOAD_TIMEOUT = (3, 7)
+_CENTRAL_SEARCH_TIMEOUT = 2.5  # seconds - search budget
 _MAVEN_JAR_HTTP_TIMEOUT = (2, 2)  # match Util probe timeouts for multi-repo jar checks
-_MAX_RETRY = 3                 # maximum Central API retry attempts per JAR
 _central_network_warned = False  # Flag to suppress repeated network-unavailable warnings within one run
+_central_lookup_warned = False  # Flag to suppress repeated lookup-failure warnings within one run
 _COORD_TOKEN = re.compile(r'[A-Za-z0-9._+-]+')  # shape of a Maven groupId / artifactId / version
 
+# Outcome of one SHA-1 search. Only a 200 reply carries an answer from the
+# Central index, so only _SEARCH_MISS states that a SHA-1 is not published
+# there. _SEARCH_FAILED means the question was never answered: a JAR the index
+# did not identify is not the same as a JAR with no OSS to report, and reporting
+# the two alike lets a rate-limited scan look like a clean one.
+_SEARCH_HIT = 'hit'
+_SEARCH_MISS = 'miss'
+_SEARCH_FAILED = 'failed'
+_SEARCH_TIMED_OUT = 'timed_out'
+
+# Reported alongside the coordinate source when a SHA-1 miss suppresses the
+# Download Location, so the empty column has a stated reason in the report.
+_SHA1_MISS_COMMENT = 'SHA-1 not in Maven Central'
+
 
 def _sha1_of_file(filepath):
     h = hashlib.sha1()
@@ -122,61 +139,82 @@ def _warn_network_once(context=""):
         _central_network_warned = True
 
 
-def _search_central_by_sha1(sha1, timeout=None):
-    """Look up Maven coordinates by JAR checksum, trying each Central host in turn.
+def _warn_lookup_failed_once(reason, context=""):
+    """Warn once per run that a Central lookup produced no answer at all."""
+    global _central_lookup_warned
+    if not _central_lookup_warned:
+        msg = f"Maven Central 조회에 실패했습니다 ({reason}) - 일부 JAR의 OSS 식별이 누락될 수 있습니다"
+        if context:
+            msg += f" [{context}]"
+        logger.warning(msg)
+        _central_lookup_warned = True
 
-    An answer from any host is authoritative for the whole index, so a miss ends
-    the search. ``timed_out`` is reported only when no host answered at all.
+
+def _search_central_by_sha1(sha1, timeout=None):
+    """Look up Maven coordinates by JAR checksum on the Central Portal endpoint.
+
+    Returns ``(coordinates, outcome)``. A 200 reply is final: a complete
+    coordinate triple is ``_SEARCH_HIT``, and no document or an incomplete one
+    is ``_SEARCH_MISS``, a normal result that stays quiet. A reply carrying no
+    index answer is ``_SEARCH_FAILED`` and warns once per run so it cannot pass
+    as a miss - non-200 and unparseable bodies through
+    ``_warn_lookup_failed_once``, a refused connection through
+    ``_warn_network_once``, whose flags are independent. A timeout is separate:
+    ``_SEARCH_TIMED_OUT`` with a debug log and no warning, because the retry
+    policy meant to warn after exhausting its rounds is not implemented yet.
     """
     if not sha1:
-        return {}, False
+        return {}, _SEARCH_MISS
     _timeout = timeout if timeout is not None else _CENTRAL_SEARCH_TIMEOUT
     params = {"q": f"1:{sha1}", "rows": 1, "wt": "json"}
-    any_timeout = False
-    unreachable = False
+    where = f"SHA-1 search: {sha1[:10]}..."
 
-    for url in _CENTRAL_SEARCH_URLS:
-        try:
-            resp = requests.get(url, params=params, timeout=_timeout)
-            resp.raise_for_status()
-            docs = resp.json().get("response", {}).get("docs", [])
-        except requests.exceptions.Timeout:
-            logger.debug(f"Maven Central SHA-1 search timed out ({sha1}) at {url} - will retry")
-            any_timeout = True
-            continue
-        except Exception as ex:
-            if _is_network_error(ex):
-                unreachable = True
-            else:
-                logger.debug(f"Maven Central SHA-1 search failed ({sha1}) at {url}: {ex}")
-            continue
+    try:
+        resp = requests.get(_CENTRAL_SEARCH_URL, params=params, timeout=_timeout)
+    except requests.exceptions.Timeout:
+        logger.debug(f"Maven Central SHA-1 search timed out ({sha1}) at {_CENTRAL_SEARCH_URL}")
+        return {}, _SEARCH_TIMED_OUT
+    except Exception as ex:
+        if _is_network_error(ex):
+            _warn_network_once(where)
+        else:
+            _warn_lookup_failed_once(type(ex).__name__, where)
+        logger.debug(f"Maven Central SHA-1 search failed ({sha1}) at {_CENTRAL_SEARCH_URL}: {ex}")
+        return {}, _SEARCH_FAILED
 
-        if not docs:
-            return {}, False
+    if resp.status_code != 200:
+        _warn_lookup_failed_once(f"HTTP {resp.status_code}", where)
+        logger.debug(f"Maven Central SHA-1 search got HTTP {resp.status_code} ({sha1})")
+        return {}, _SEARCH_FAILED
 
-        doc = docs[0]
-        groupId = doc.get("g", "")
-        artifactId = doc.get("a", "")
-        version = doc.get("v") or doc.get("latestVersion", "")
+    try:
+        docs = resp.json().get("response", {}).get("docs", [])
+    except Exception as ex:
+        _warn_lookup_failed_once("응답을 해석할 수 없음", where)
+        logger.debug(f"Maven Central SHA-1 search reply was unusable ({sha1}): {ex}")
+        return {}, _SEARCH_FAILED
 
-        if not (groupId and artifactId and version):
-            logger.debug(f"Maven Central returned an incomplete document for {sha1}: {doc}")
-            return {}, False
+    if not docs:
+        return {}, _SEARCH_MISS
 
-        return {
-            "groupId": groupId,
-            "artifactId": artifactId,
-            "version": version,
-        }, False
+    doc = docs[0]
+    groupId = doc.get("g", "")
+    artifactId = doc.get("a", "")
+    version = doc.get("v") or doc.get("latestVersion", "")
 
-    # Warn only once every host has failed: a fallback answer is not a failure.
-    if unreachable:
-        _warn_network_once(f"SHA-1 search: {sha1[:10]}...")
-    return {}, any_timeout
+    if not (groupId and artifactId and version):
+        logger.debug(f"Maven Central returned an incomplete document for {sha1}: {doc}")
+        return {}, _SEARCH_MISS
+
+    return {
+        "groupId": groupId,
+        "artifactId": artifactId,
+        "version": version,
+    }, _SEARCH_HIT
 
 
 def _download_pom_to_tempfile(group_id, artifact_id, version, timeout=None):
-    _timeout = timeout if timeout is not None else _REQUEST_TIMEOUT
+    _timeout = timeout if timeout is not None else _POM_DOWNLOAD_TIMEOUT
     group_path = group_id.replace('.', '/')
     pom_name = f"{artifact_id}-{version}.pom"
     urls = [
@@ -193,7 +231,7 @@ def _download_pom_to_tempfile(group_id, artifact_id, version, timeout=None):
                 logger.debug(f"POM downloaded to {tmp.name} from {url}")
                 return tmp.name, False
         except requests.exceptions.Timeout:
-            logger.debug(f"POM download timed out from {url} - will retry")
+            logger.debug(f"POM download timed out from {url} - trying next repository")
             any_timeout = True
         except Exception as ex:
             if _is_network_error(ex):
@@ -253,20 +291,17 @@ def _find_jar_download_url(group_id, artifact_id, version):
     return ""
 
 
-def _process_one_jar(jar_path, rel_path, sha1, search_timeout=None, skip_central_search=False):
+def _process_one_jar(jar_path, rel_path, sha1, search_timeout=None):
     groupId = artifactId = version = project_url = license_str = ''
     confirmed_in_central = False
     trusted_coordinates = False
     source = ''
 
-    if skip_central_search:
-        central_info = {}
-        timed_out = False
-    else:
-        central_info, timed_out = _search_central_by_sha1(sha1, timeout=search_timeout)
-        if timed_out:
-            logger.debug(f"{rel_path}: Central SHA-1 search timed out - will retry")
-            return None, True
+    central_info, search_outcome = _search_central_by_sha1(sha1, timeout=search_timeout)
+    if search_outcome == _SEARCH_TIMED_OUT:
+        logger.debug(f"{rel_path}: Central SHA-1 search timed out - falling back to JAR internals")
+    elif search_outcome == _SEARCH_FAILED:
+        logger.debug(f"{rel_path}: Central SHA-1 lookup failed - falling back to JAR internals")
 
     g2, a2, v2, url2, pom_tmp_path = _read_pom_from_jar(jar_path)
 
@@ -282,7 +317,7 @@ def _process_one_jar(jar_path, rel_path, sha1, search_timeout=None, skip_central
         if names_match:
             logger.debug(f"{rel_path}: Central and JAR pom.xml match ({central_oss_name} {c_version}) - using JAR pom.xml for license")
             groupId, artifactId, version, project_url = g2, a2, v2, url2
-            source = 'pom.xml'
+            source = 'pom.xml (Central verified)'
             confirmed_in_central = True
             trusted_coordinates = True
 
@@ -307,16 +342,19 @@ def _process_one_jar(jar_path, rel_path, sha1, search_timeout=None, skip_central
             confirmed_in_central = True
             trusted_coordinates = True
 
-            tmp_path, timed_out = _download_pom_to_tempfile(
-                groupId, artifactId, version, timeout=search_timeout)
+            tmp_path, timed_out = _download_pom_to_tempfile(groupId, artifactId, version)
             if timed_out:
-                logger.debug(f"{rel_path}: POM download timed out - will retry")
+                logger.warning(
+                    f"{rel_path}: POM download timed out for {groupId}:{artifactId}:{version}"
+                    " - using JAR pom.xml license")
                 if pom_tmp_path:
                     try:
-                        os.remove(pom_tmp_path)
-                    except Exception:
-                        pass
-                return None, True
+                        license_str = get_license_from_pom(
+                            group_id=g2, artifact_id=a2, version=v2,
+                            pom_path=pom_tmp_path, check_parent=True)
+                        logger.debug(f"{rel_path}: license from JAR pom.xml after Central POM timeout={license_str!r}")
+                    except Exception as ex:
+                        logger.debug(f"get_license_from_pom (jar pom_path) failed: {ex}")
             if tmp_path:
                 try:
                     license_str = get_license_from_pom(
@@ -338,11 +376,12 @@ def _process_one_jar(jar_path, rel_path, sha1, search_timeout=None, skip_central
                 pass
 
     else:
-        logger.debug(f"{rel_path}: not found in Maven Central - falling back to JAR internals")
+        if search_outcome == _SEARCH_MISS:
+            logger.debug(f"{rel_path}: not found in Maven Central - falling back to JAR internals")
 
         if g2 or a2:
             groupId, artifactId, version, project_url = g2, a2, v2, url2
-            source = 'pom.xml'
+            source = 'pom.xml (Local)'
             trusted_coordinates = True
 
         if pom_tmp_path:
@@ -372,9 +411,22 @@ def _process_one_jar(jar_path, rel_path, sha1, search_timeout=None, skip_central
             trusted_coordinates = False
 
     if not (groupId or artifactId):
-        return None, False
-
-    if confirmed_in_central or trusted_coordinates:
+        return None
+
+    # A miss is Central's answer that these exact bytes are not published. The
+    # JAR's own pom.xml may still name real coordinates, so a URL built from them
+    # would resolve - but it would serve the upstream artifact, not this file. A
+    # locally patched JAR keeps the official pom.xml, so filling the URL would
+    # report a modified binary as the official one. Omit it and say why; the
+    # probe is skipped because its result could not be reported anyway. A lookup
+    # that never answered (failed / timed out) is not a miss and still fills the
+    # URL, so an unreachable Central does not blank the whole report.
+    unverified_after_miss = (search_outcome == _SEARCH_MISS
+                             and trusted_coordinates and not confirmed_in_central)
+
+    if unverified_after_miss:
+        dl_url = ""
+    elif confirmed_in_central or trusted_coordinates:
         dl_url = _find_jar_download_url(groupId, artifactId, version)
     else:
         dl_url = ""
@@ -383,11 +435,13 @@ def _process_one_jar(jar_path, rel_path, sha1, search_timeout=None, skip_central
 
     oss = OssItem(oss_name, version, license_str, dl_url)
     oss.comment = source
+    if unverified_after_miss:
+        oss.comment = _SHA1_MISS_COMMENT
 
     logger.debug(
         f"Result: {rel_path} | {oss_name} {version} | [{license_str}] | dl={dl_url} | source={source}")
 
-    return {"oss_list": [oss]}, False
+    return {"oss_list": [oss]}
 
 
 def _has_valid_jar_oss(oss_list):
@@ -404,12 +458,12 @@ def _store_jar_result(jar_items, sha1, result):
 
 
 def analyze_jar_file(path_to_find_bin, path_to_exclude):
-    global _central_network_warned
+    global _central_network_warned, _central_lookup_warned
     _central_network_warned = False
+    _central_lookup_warned = False
     jar_items = {}
+    analyzed = set()
     success = True
-    retry_queue = []
-    pending_sha1s = set()
 
     jar_files = []
     for root_dir, _dirs, files in os.walk(path_to_find_bin):
@@ -427,42 +481,15 @@ def analyze_jar_file(path_to_find_bin, path_to_exclude):
             continue
 
         sha1 = _sha1_of_file(jar_path)
-        if not sha1 or sha1 in jar_items or sha1 in pending_sha1s:
+        if not sha1 or sha1 in analyzed:
             continue
+        analyzed.add(sha1)
 
-        result, needs_retry = _process_one_jar(
+        result = _process_one_jar(
             jar_path, rel_path, sha1, search_timeout=_CENTRAL_SEARCH_TIMEOUT)
-
-        if needs_retry:
-            logger.debug(f"{rel_path}: Central API timed out - queued for retry (attempt 1/{_MAX_RETRY})")
-            pending_sha1s.add(sha1)
-            retry_queue.append((jar_path, rel_path, sha1, 1))
-        elif result is not None:
+        if result is not None:
             _store_jar_result(jar_items, sha1, result)
 
-    while retry_queue:
-        next_queue = []
-        for jar_path, rel_path, sha1, attempt in retry_queue:
-            if attempt >= _MAX_RETRY:
-                logger.warning(
-                    f"{rel_path}: Maven Central API timed out after {_MAX_RETRY} attempts"
-                    " - falling back to JAR internals")
-                result, _ = _process_one_jar(jar_path, rel_path, sha1, skip_central_search=True)
-                if result is not None:
-                    _store_jar_result(jar_items, sha1, result)
-                continue
-
-            logger.debug(f"{rel_path}: retrying Central API (attempt {attempt + 1}/{_MAX_RETRY})")
-            result, needs_retry = _process_one_jar(
-                jar_path, rel_path, sha1, search_timeout=_CENTRAL_SEARCH_TIMEOUT)
-
-            if needs_retry:
-                next_queue.append((jar_path, rel_path, sha1, attempt + 1))
-            elif result is not None:
-                _store_jar_result(jar_items, sha1, result)
-
-        retry_queue = next_queue
-
     return jar_items, success
 
 

{fosslight_binary-5.1.32 → fosslight_binary-5.1.34}/src/fosslight_binary/binary_analysis.py

@@ -33,7 +33,7 @@ import shutil
 PKG_NAME = "fosslight_binary"
 logger = logging.getLogger(constant.LOGGER_NAME)
 
-_REMOVE_FILE_EXTENSION = ['json', 'js']
+_REMOVE_FILE_EXTENSION = ['json', 'js', 'xlsx', 'xls', 'xlsm']
 _REMOVE_FILE_COMMAND_RESULT = ['timezone data', 'apple binary property list']
 INCLUDE_FILE_COMMAND_RESULT = ['current ar archive']
 
@@ -86,7 +86,9 @@ def init(path_to_find_bin, output_file_name, formats, path_to_exclude=[]):
             output_path = os.path.abspath(output_path)
 
         original_output_path = output_path
-        output_path = os.path.join(output_path, '.fosslight_temp')
+        output_path = os.path.join(output_path, f'.fosslight_temp_{file_time}')
+        if os.path.isdir(output_path):
+            shutil.rmtree(output_path, ignore_errors=True)
 
         while len(output_files) < len(output_extensions):
             output_files.append(None)
@@ -181,12 +183,18 @@ def find_binaries(path_to_find_bin, output_dir, formats, kb_url="", kb_token="",
     if not path_to_find_bin.endswith(os.path.sep):
         _root_path += os.path.sep
 
+    output_path = ""
+    original_output_path = ""
+    log_file = ""
+    final_log_path = ""
+
     if simple_mode:
         mode = "Simple Mode"
         _result_log, binary_yaml_file, compressed_yaml_file = init_simple(output_dir, PKG_NAME, start_time)
     else:
         _result_log, result_reports, output_extensions, formats, output_path, original_output_path, log_file = init(
             path_to_find_bin, output_dir, formats, path_to_exclude)
+        final_log_path = os.path.join(original_output_path, f"fosslight_log_bin_{timestamp_for_filename(start_time)}.txt")
 
     total_bin_cnt = 0
     db_loaded_cnt = 0
@@ -196,130 +204,139 @@ def find_binaries(path_to_find_bin, output_dir, formats, kb_url="", kb_token="",
     bin_list = []
     scan_item = ScannerItem(PKG_NAME, "")
 
-    if all_exclude_mode and len(all_exclude_mode) == 4:
-        excluded_path_with_default_exclusion, excluded_path_without_dot, excluded_files, cnt_file_except_skipped = all_exclude_mode
-    elif simple_mode:
-        excluded_path_with_default_exclusion, excluded_path_without_dot, excluded_files, cnt_file_except_skipped \
-            = get_excluded_paths(
-                path_to_find_bin, path_to_exclude, REMOVE_FILE_EXTENSION_SIMPLE,
-                exclude_filenames=EXCLUDE_FILENAME_BINARY)
-    else:
-        excluded_path_with_default_exclusion, excluded_path_without_dot, excluded_files, cnt_file_except_skipped \
-            = get_excluded_paths(
-                path_to_find_bin, path_to_exclude,
-                exclude_filenames=EXCLUDE_FILENAME_BINARY)
-    logger.debug(f"Skipped paths: {excluded_path_with_default_exclusion}")
-
-    if not os.path.isdir(path_to_find_bin):
-        error_occured(error_msg=f"(-p option) Can't find the directory: {path_to_find_bin}",
-                      result_log=_result_log,
-                      exit=True,
-                      mode=mode)
-    if not correct_filepath:
-        correct_filepath = path_to_find_bin
     try:
-        _, file_list, found_jar = get_file_list(path_to_find_bin, excluded_files)
-        return_list = list(return_bin_only(file_list))
-    except Exception as ex:
-        error_occured(error_msg=f"Failed to check whether it is binary or not : {ex}",
-                      result_log=_result_log,
-                      exit=True,
-                      mode=mode)
-    if simple_mode:
+        if all_exclude_mode and len(all_exclude_mode) == 4:
+            excluded_path_with_default_exclusion, excluded_path_without_dot, excluded_files, cnt_file_except_skipped = all_exclude_mode
+        elif simple_mode:
+            excluded_path_with_default_exclusion, excluded_path_without_dot, excluded_files, cnt_file_except_skipped \
+                = get_excluded_paths(
+                    path_to_find_bin, path_to_exclude, REMOVE_FILE_EXTENSION_SIMPLE,
+                    exclude_filenames=EXCLUDE_FILENAME_BINARY)
+        else:
+            excluded_path_with_default_exclusion, excluded_path_without_dot, excluded_files, cnt_file_except_skipped \
+                = get_excluded_paths(
+                    path_to_find_bin, path_to_exclude,
+                    exclude_filenames=EXCLUDE_FILENAME_BINARY)
+        logger.debug(f"Skipped paths: {excluded_path_with_default_exclusion}")
+
+        if not os.path.isdir(path_to_find_bin):
+            error_occured(error_msg=f"(-p option) Can't find the directory: {path_to_find_bin}",
+                          result_log=_result_log,
+                          exit=True,
+                          mode=mode)
+
+        if not correct_filepath:
+            correct_filepath = path_to_find_bin
         try:
-            compressed_list, filtered_bin_list = filter_binary(return_list)
-            results = print_simple_mode(binary_yaml_file, compressed_yaml_file, compressed_list, filtered_bin_list)
-            total_bin_cnt = len(filtered_bin_list) + len(compressed_list)
+            _, file_list, found_jar = get_file_list(path_to_find_bin, excluded_files)
+            return_list = list(return_bin_only(file_list))
         except Exception as ex:
-            error_occured(error_msg=f"Failed to run simple mode: {ex}",
+            error_occured(error_msg=f"Failed to check whether it is binary or not : {ex}",
                           result_log=_result_log,
                           exit=True,
-                          mode="Simple mode")
+                          mode=mode)
 
-        for success_to_write, writing_msg, result_file in results:
-            if success_to_write:
-                if result_file:
-                    logger.info(f"Output file :{result_file}")
-                else:
-                    logger.warning(f"{writing_msg}")
-            else:
-                logger.error(f"Fail to generate result file.:{writing_msg}")
-    else:
-        total_bin_cnt = len(return_list)
-        scan_item = ScannerItem(PKG_NAME, start_time)
-        scan_item.set_cover_pathinfo(path_to_find_bin, excluded_path_without_dot)
-        try:
-            # Run JAR analysis via Maven Central API
-            if found_jar:
-                logger.info("Run to analyze .jar file")
-                jar_items, success = analyze_jar_file(path_to_find_bin, excluded_files)
-                if success:
-                    return_list = merge_binary_list(jar_items, return_list)
-                else:
-                    logger.warning("Could not find OSS information for some jar files.")
-
-            return_list, db_loaded_cnt, kb_cover_msg = get_oss_info_from_db(return_list, kb_url, kb_token)
-            return_list = sorted(return_list, key=lambda row: (row.bin_name_with_path))
-            scan_item.append_file_items(return_list, PKG_NAME)
-            if correct_mode:
-                success, msg_correct, correct_list = correct_with_yaml(correct_filepath, path_to_find_bin, scan_item)
-                if not success:
-                    logger.info(f"No correction with yaml: {msg_correct}")
+        if simple_mode:
+            try:
+                compressed_list, filtered_bin_list = filter_binary(return_list)
+                results = print_simple_mode(binary_yaml_file, compressed_yaml_file, compressed_list, filtered_bin_list)
+                total_bin_cnt = len(filtered_bin_list) + len(compressed_list)
+            except Exception as ex:
+                error_occured(error_msg=f"Failed to run simple mode: {ex}",
+                              result_log=_result_log,
+                              exit=True,
+                              mode="Simple mode")
+
+            for success_to_write, writing_msg, result_file in results:
+                if success_to_write:
+                    if result_file:
+                        logger.info(f"Output file :{result_file}")
+                    else:
+                        logger.warning(f"{writing_msg}")
                 else:
-                    return_list = correct_list
-                    logger.info("Success to correct with yaml.")
+                    logger.error(f"Fail to generate result file.:{writing_msg}")
+        else:
+            total_bin_cnt = len(return_list)
+            scan_item = ScannerItem(PKG_NAME, start_time)
+            scan_item.set_cover_pathinfo(path_to_find_bin, excluded_path_without_dot)
+            try:
+                if found_jar:
+                    logger.info("Run to analyze .jar file")
+                    jar_items, success = analyze_jar_file(path_to_find_bin, excluded_files)
+                    if success:
+                        return_list = merge_binary_list(jar_items, return_list)
+                    else:
+                        logger.warning("Could not find OSS information for some jar files.")
+
+                return_list, db_loaded_cnt, kb_cover_msg = get_oss_info_from_db(return_list, kb_url, kb_token)
+                return_list = sorted(return_list, key=lambda row: (row.bin_name_with_path))
+                scan_item.append_file_items(return_list, PKG_NAME)
+                if correct_mode:
+                    success, msg_correct, correct_list = correct_with_yaml(correct_filepath, path_to_find_bin, scan_item)
+                    if not success:
+                        logger.info(f"No correction with yaml: {msg_correct}")
+                    else:
+                        return_list = correct_list
+                        logger.info("Success to correct with yaml.")
 
-            finish_time = current_timestamp_utc()
-            scan_item.set_cover_comment(f"Detected binaries: {len(return_list)} (Scanned Files : {cnt_file_except_skipped})")
-            if kb_cover_msg:
-                scan_item.set_cover_comment(kb_cover_msg)
-            scan_item.set_cover_finish_time(finish_time)
+                finish_time = current_timestamp_utc()
+                scan_item.set_cover_comment(f"Detected binaries: {len(return_list)} (Scanned Files : {cnt_file_except_skipped})")
+                if kb_cover_msg:
+                    scan_item.set_cover_comment(kb_cover_msg)
+                scan_item.set_cover_finish_time(finish_time)
 
-            for combined_path_and_file, output_extension, output_format in zip(result_reports, output_extensions, formats):
-                results.append(write_output_file(combined_path_and_file, output_extension, scan_item,
-                                                 BIN_EXT_HEADER, HIDE_HEADER, output_format,
-                                                 scanner_covers=[scan_item.cover]))
+                for combined_path_and_file, output_extension, output_format in zip(result_reports, output_extensions, formats):
+                    results.append(write_output_file(combined_path_and_file, output_extension, scan_item,
+                                                     BIN_EXT_HEADER, HIDE_HEADER, output_format,
+                                                     scanner_covers=[scan_item.cover]))
 
-        except Exception as ex:
-            error_occured(error_msg=str(ex), exit=False)
+            except Exception as ex:
+                error_occured(error_msg=str(ex), exit=False)
 
-        for success_to_write, writing_msg, result_file in results:
-            if success_to_write:
-                if result_file:
-                    logger.info(f"Output file :{os.path.join(original_output_path, os.path.basename(result_file))}")
+            for success_to_write, writing_msg, result_file in results:
+                if success_to_write:
+                    if result_file:
+                        logger.info(f"Output file :{os.path.join(original_output_path, os.path.basename(result_file))}")
+                    else:
+                        logger.warning(f"{writing_msg}")
+                    for row in scan_item.get_cover_comment():
+                        logger.info(row)
                 else:
-                    logger.warning(f"{writing_msg}")
-                for row in scan_item.get_cover_comment():
-                    logger.info(row)
-            else:
-                logger.error(f"Fail to generate result file.:{writing_msg}")
+                    logger.error(f"Fail to generate result file.:{writing_msg}")
 
-        try:
-            if os.path.isfile(log_file):
-                move_log_file(log_file, os.path.join(original_output_path, f"fosslight_log_bin_{timestamp_for_filename(start_time)}.txt"))
-            else:
-                logger.debug("Moving binary analysis log file is skipped")
-        except Exception as ex:
-            logger.debug(f"Failed to move log file: {ex}")
+            try:
+                if os.path.isdir(output_path):
+                    shutil.copytree(output_path, original_output_path, dirs_exist_ok=True)
+                else:
+                    logger.debug(f"Temp directory not found, skip moving: {output_path}")
+            except Exception as ex:
+                logger.debug(f"Failed to move temp files: {ex}")
+                success_to_write = False
 
         try:
-            if os.path.isdir(output_path):
-                shutil.copytree(output_path, original_output_path, dirs_exist_ok=True)
-                shutil.rmtree(output_path)
-            else:
-                logger.debug(f"Temp directory not found, skip moving: {output_path}")
+            print_result_log(mode=mode, success=True, result_log=_result_log,
+                             file_cnt=str(cnt_file_except_skipped),
+                             bin_file_cnt=str(total_bin_cnt),
+                             auto_bin_cnt=str(db_loaded_cnt), bin_list=bin_list)
         except Exception as ex:
-            logger.debug(f"Failed to move temp files: {ex}")
+            error_occured(error_msg=f"Print log : {ex}", exit=False)
 
-    try:
-        print_result_log(mode=mode, success=True, result_log=_result_log,
-                         file_cnt=str(cnt_file_except_skipped),
-                         bin_file_cnt=str(total_bin_cnt),
-                         auto_bin_cnt=str(db_loaded_cnt), bin_list=bin_list)
-    except Exception as ex:
-        error_occured(error_msg=f"Print log : {ex}", exit=False)
+        return success_to_write, scan_item
+    finally:
+        if output_path:
+            try:
+                if log_file and final_log_path and os.path.isfile(log_file):
+                    move_log_file(log_file, final_log_path)
+                elif log_file:
+                    logger.debug("Moving binary analysis log file is skipped")
+            except Exception as ex:
+                logger.debug(f"Failed to move log file: {ex}")
 
-    return success_to_write, scan_item
+            try:
+                if os.path.isdir(output_path):
+                    shutil.rmtree(output_path)
+            except Exception as ex:
+                logger.debug(f"Failed to cleanup temp files: {ex}")
 
 
 def return_bin_only(file_list, need_checksum_tlsh=True):

{fosslight_binary-5.1.32 → fosslight_binary-5.1.34}/src/fosslight_binary.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fosslight_binary
-Version: 5.1.32
+Version: 5.1.34
 Summary: FOSSLight Binary Scanner
 Author: LG Electronics
 License-Expression: Apache-2.0