codecov-cli 11.0.0__py3-none-any.whl

codecov_cli/services/upload/upload_sender.py

@@ -0,0 +1,232 @@
+import base64
+import json
+import logging
+import typing
+import zlib
+from typing import Any, Dict
+
+import sentry_sdk
+
+from codecov_cli import __version__ as codecov_cli_version
+from codecov_cli.helpers.config import CODECOV_INGEST_URL
+from codecov_cli.helpers.encoder import encode_slug
+from codecov_cli.helpers.upload_type import ReportType
+from codecov_cli.helpers.request import (
+    get_token_header,
+    send_post_request,
+    send_put_request,
+)
+from codecov_cli.types import (
+    RequestResult,
+    UploadCollectionResult,
+    UploadCollectionResultFile,
+)
+
+logger = logging.getLogger("codecovcli")
+
+
+class UploadSender(object):
+    def send_upload_data(
+        self,
+        upload_data: UploadCollectionResult,
+        commit_sha: str,
+        token: typing.Optional[str],
+        env_vars: typing.Dict[str, str],
+        report_code: str,
+        report_type: ReportType = ReportType.COVERAGE,
+        name: typing.Optional[str] = None,
+        branch: typing.Optional[str] = None,
+        slug: typing.Optional[str] = None,
+        pull_request_number: typing.Optional[str] = None,
+        build_code: typing.Optional[str] = None,
+        build_url: typing.Optional[str] = None,
+        job_code: typing.Optional[str] = None,
+        flags: typing.List[str] = None,
+        ci_service: typing.Optional[str] = None,
+        git_service: typing.Optional[str] = None,
+        enterprise_url: typing.Optional[str] = None,
+        parent_sha: typing.Optional[str] = None,
+        upload_coverage: bool = False,
+        args: dict = None,
+    ) -> RequestResult:
+        current_transaction = sentry_sdk.get_current_scope().transaction
+        if current_transaction:
+            current_transaction.set_data("commit_sha", commit_sha)
+            current_transaction.set_data("slug", slug)
+
+        with sentry_sdk.start_span(name="upload_sender"):
+            with sentry_sdk.start_span(name="upload_sender_preparation"):
+                file_not_found = False
+                if report_type == ReportType.TEST_RESULTS and not upload_data.files:
+                    file_not_found = True
+
+                data = {
+                    "ci_service": ci_service,
+                    "ci_url": build_url,
+                    "cli_args": args,
+                    "env": env_vars,
+                    "flags": flags,
+                    "job_code": job_code,
+                    "name": name,
+                    "version": codecov_cli_version,
+                    "file_not_found": file_not_found,
+                }
+
+                if upload_coverage:
+                    data["branch"] = branch
+                    data["code"] = report_code
+                    data["commitid"] = commit_sha
+                    data["parent_commit_id"] = parent_sha
+                    data["pullid"] = pull_request_number
+                headers = get_token_header(token)
+                encoded_slug = encode_slug(slug)
+                upload_url = enterprise_url or CODECOV_INGEST_URL
+                url, data = self.get_url_and_possibly_update_data(
+                    data,
+                    report_type,
+                    upload_url,
+                    git_service,
+                    branch,
+                    encoded_slug,
+                    commit_sha,
+                    report_code,
+                    upload_coverage,
+                )
+                # Data that goes to storage
+                reports_payload = self._generate_payload(
+                    upload_data, env_vars, report_type
+                )
+
+            with sentry_sdk.start_span(name="upload_sender_storage_request"):
+                logger.debug("Sending upload request to Codecov")
+                resp_from_codecov = send_post_request(
+                    url=url,
+                    data=data,
+                    headers=headers,
+                )
+
+                if file_not_found:
+                    logger.info(
+                        "No test results reports found. Triggering notifications without uploading."
+                    )
+                    return resp_from_codecov
+
+                if resp_from_codecov.status_code >= 400:
+                    return resp_from_codecov
+                resp_json_obj = json.loads(resp_from_codecov.text)
+                if resp_json_obj.get("url"):
+                    logger.info(
+                        f"Your upload is now processing. When finished, results will be available at: {resp_json_obj.get('url')}"
+                    )
+                logger.debug(
+                    "Upload request to Codecov complete.",
+                    extra=dict(extra_log_attributes=dict(response=resp_json_obj)),
+                )
+                put_url = resp_json_obj["raw_upload_location"]
+
+            with sentry_sdk.start_span(name="upload_sender_storage"):
+                logger.debug("Sending upload to storage")
+                resp_from_storage = send_put_request(put_url, data=reports_payload)
+
+            return resp_from_storage
+
+    def _generate_payload(
+        self,
+        upload_data: UploadCollectionResult,
+        env_vars: typing.Dict[str, str],
+        report_type: ReportType = ReportType.COVERAGE,
+    ) -> bytes:
+        network_files = upload_data.network
+        if report_type == ReportType.COVERAGE:
+            payload = {
+                "report_fixes": {
+                    "format": "legacy",
+                    "value": self._get_file_fixers(upload_data),
+                },
+                "network_files": network_files if network_files is not None else [],
+                "coverage_files": self._get_files(upload_data),
+                "metadata": {},
+            }
+        elif report_type == ReportType.TEST_RESULTS:
+            payload = {
+                "test_results_files": self._get_files(upload_data),
+            }
+
+        json_data = json.dumps(payload)
+        return json_data.encode()
+
+    def _get_file_fixers(
+        self, upload_data: UploadCollectionResult
+    ) -> Dict[str, Dict[str, Any]]:
+        """
+        Returns file/path fixes in the following format:
+
+        {
+            {path}: {
+                "eof": int(eof_line),
+                "lines": {set_of_lines},
+            },
+        }
+        """
+        file_fixers = {}
+        for file_fixer in upload_data.file_fixes:
+            fixed_lines_with_reason = set(
+                [fixer[0] for fixer in file_fixer.fixed_lines_with_reason]
+            )
+            total_fixed_lines = list(
+                file_fixer.fixed_lines_without_reason.union(fixed_lines_with_reason)
+            )
+            file_fixers[file_fixer.path.as_posix()] = {
+                "eof": file_fixer.eof,
+                "lines": total_fixed_lines,
+            }
+
+        return file_fixers
+
+    def _get_files(self, upload_data: UploadCollectionResult):
+        return [self._format_file(file) for file in upload_data.files]
+
+    def _format_file(self, file: UploadCollectionResultFile):
+        format, formatted_content = self._get_format_info(file)
+        return {
+            "filename": file.get_filename(),
+            "format": format,
+            "data": formatted_content,
+            "labels": "",
+        }
+
+    def _get_format_info(self, file: UploadCollectionResultFile):
+        format = "base64+compressed"
+        formatted_content = (
+            base64.b64encode(zlib.compress((file.get_content())))
+        ).decode()
+        return format, formatted_content
+
+    def get_url_and_possibly_update_data(
+        self,
+        data,
+        report_type: ReportType,
+        upload_url,
+        git_service,
+        branch,
+        encoded_slug,
+        commit_sha,
+        report_code,
+        upload_coverage=False,
+        file_not_found=False,
+    ):
+        if report_type == ReportType.COVERAGE:
+            base_url = f"{upload_url}/upload/{git_service}/{encoded_slug}"
+            if upload_coverage:
+                url = f"{base_url}/upload-coverage"
+            else:
+                url = f"{base_url}/commits/{commit_sha}/reports/{report_code}/uploads"
+        elif report_type == ReportType.TEST_RESULTS:
+            data["slug"] = encoded_slug
+            data["branch"] = branch
+            data["commit"] = commit_sha
+            data["service"] = git_service
+            data["file_not_found"] = file_not_found
+            url = f"{upload_url}/upload/test_results/v1"
+
+        return url, data

codecov_cli/services/upload_completion/__init__.py

@@ -0,0 +1,38 @@
+import json
+import logging
+
+from codecov_cli.helpers.config import CODECOV_API_URL
+from codecov_cli.helpers.encoder import encode_slug
+from codecov_cli.helpers.request import (
+    get_token_header,
+    log_warnings_and_errors_if_any,
+    send_post_request,
+)
+
+logger = logging.getLogger("codecovcli")
+
+
+def upload_completion_logic(
+    commit_sha,
+    slug,
+    token,
+    git_service,
+    enterprise_url,
+    fail_on_error=False,
+    args=None,
+):
+    encoded_slug = encode_slug(slug)
+    headers = get_token_header(token)
+    upload_url = enterprise_url or CODECOV_API_URL
+    url = f"{upload_url}/upload/{git_service}/{encoded_slug}/commits/{commit_sha}/upload-complete"
+    data = {
+        "cli_args": args,
+    }
+    sending_result = send_post_request(url=url, data=data, headers=headers)
+    log_warnings_and_errors_if_any(
+        sending_result, "Upload Completion", fail_on_error=fail_on_error
+    )
+    if sending_result.status_code == 200:
+        response_json = json.loads(sending_result.text)
+        logger.info(response_json)
+    return sending_result

codecov_cli/services/upload_coverage/__init__.py

@@ -0,0 +1,93 @@
+import pathlib
+import typing
+
+from codecov_cli.helpers.ci_adapters.base import CIAdapterBase
+from codecov_cli.helpers.versioning_systems import VersioningSystemInterface
+from codecov_cli.services.upload import do_upload_logic
+from codecov_cli.helpers.upload_type import ReportType
+
+
+def upload_coverage_logic(
+    cli_config: typing.Dict,
+    versioning_system: VersioningSystemInterface,
+    ci_adapter: CIAdapterBase,
+    *,
+    branch: typing.Optional[str],
+    build_code: typing.Optional[str],
+    build_url: typing.Optional[str],
+    commit_sha: str,
+    recurse_submodules: bool,
+    disable_file_fixes: bool,
+    disable_search: bool,
+    dry_run: bool,
+    enterprise_url: typing.Optional[str],
+    env_vars: typing.Dict[str, str],
+    fail_on_error: bool,
+    files_search_exclude_folders: typing.List[pathlib.Path],
+    files_search_explicitly_listed_files: typing.List[pathlib.Path],
+    files_search_root_folder: pathlib.Path,
+    flags: typing.List[str],
+    gcov_args: typing.Optional[str],
+    gcov_executable: typing.Optional[str],
+    gcov_ignore: typing.Optional[str],
+    gcov_include: typing.Optional[str],
+    git_service: typing.Optional[str],
+    handle_no_reports_found: bool,
+    job_code: typing.Optional[str],
+    name: typing.Optional[str],
+    network_filter: typing.Optional[str],
+    network_prefix: typing.Optional[str],
+    network_root_folder: pathlib.Path,
+    parent_sha: typing.Optional[str],
+    plugin_names: typing.List[str],
+    pull_request_number: typing.Optional[str],
+    report_code: str,
+    slug: typing.Optional[str],
+    swift_project: typing.Optional[str],
+    token: typing.Optional[str],
+    use_legacy_uploader: bool,
+    report_type: ReportType = ReportType.COVERAGE,
+    args: dict = None,
+):
+    return do_upload_logic(
+        cli_config=cli_config,
+        versioning_system=versioning_system,
+        ci_adapter=ci_adapter,
+        upload_coverage=True,
+        args=args,
+        branch=branch,
+        build_code=build_code,
+        build_url=build_url,
+        commit_sha=commit_sha,
+        recurse_submodules=recurse_submodules,
+        disable_file_fixes=disable_file_fixes,
+        disable_search=disable_search,
+        dry_run=dry_run,
+        enterprise_url=enterprise_url,
+        env_vars=env_vars,
+        fail_on_error=fail_on_error,
+        files_search_exclude_folders=files_search_exclude_folders,
+        files_search_explicitly_listed_files=files_search_explicitly_listed_files,
+        files_search_root_folder=files_search_root_folder,
+        flags=flags,
+        gcov_args=gcov_args,
+        gcov_executable=gcov_executable,
+        gcov_ignore=gcov_ignore,
+        gcov_include=gcov_include,
+        git_service=git_service,
+        handle_no_reports_found=handle_no_reports_found,
+        job_code=job_code,
+        name=name,
+        network_filter=network_filter,
+        network_prefix=network_prefix,
+        network_root_folder=network_root_folder,
+        parent_sha=parent_sha,
+        plugin_names=plugin_names,
+        pull_request_number=pull_request_number,
+        report_code=report_code,
+        slug=slug,
+        swift_project=swift_project,
+        token=token,
+        use_legacy_uploader=use_legacy_uploader,
+        report_type=report_type,
+    )

codecov_cli/types.py

@@ -0,0 +1,88 @@
+import pathlib
+import typing as t
+from dataclasses import dataclass
+
+import click
+
+from codecov_cli.helpers.ci_adapters.base import CIAdapterBase
+from codecov_cli.helpers.versioning_systems import VersioningSystemInterface
+
+
+class ContextObject(t.TypedDict):
+    ci_adapter: t.Optional[CIAdapterBase]
+    versioning_system: t.Optional[VersioningSystemInterface]
+    codecov_yaml: t.Optional[dict]
+    enterprise_url: t.Optional[str]
+
+
+class CommandContext(click.Context):
+    obj: ContextObject
+
+
+class UploadCollectionResultFile(object):
+    def __init__(self, path: pathlib.Path):
+        self.path = path
+
+    def get_filename(self) -> str:
+        return self.path.as_posix()
+
+    def get_content(self) -> bytes:
+        with open(self.path, "rb") as f:
+            return f.read()
+
+    def __repr__(self) -> str:
+        return str(self.path)
+
+    def __eq__(self, other):
+        if not isinstance(other, UploadCollectionResultFile):
+            return False
+
+        return self.path == other.path
+
+    def __hash__(self) -> int:
+        return hash(str(self.path))
+
+
+@dataclass
+class UploadCollectionResultFileFixer(object):
+    __slots__ = ["path", "fixed_lines_without_reason", "fixed_lines_with_reason", "eof"]
+    path: pathlib.Path
+    fixed_lines_without_reason: t.Set[int]
+    fixed_lines_with_reason: t.Optional[t.Set[t.Tuple[int, str]]]
+    eof: t.Optional[int]
+
+
+@dataclass
+class UploadCollectionResult(object):
+    __slots__ = ["network", "files", "file_fixes"]
+    network: t.List[str]
+    files: t.List[UploadCollectionResultFile]
+    file_fixes: t.List[UploadCollectionResultFileFixer]
+
+
+class PreparationPluginInterface(object):
+    def run_preparation(self) -> None:
+        pass
+
+
+@dataclass
+class RequestResultWarning(object):
+    __slots__ = ("message",)
+    message: str
+
+
+@dataclass
+class RequestError(object):
+    __slots__ = ("code", "params", "description")
+    code: str
+    params: t.Dict
+    description: str
+
+
+@dataclass
+class RequestResult(object):
+    __slots__ = ("error", "warnings", "status_code", "text")
+    error: t.Optional[RequestError]
+    warnings: t.List[RequestResultWarning]
+    status_code: int
+    text: str