infrahub-server 1.1.6__py3-none-any.whl → 1.2.0b1__py3-none-any.whl

infrahub/graphql/query.py

@@ -1,52 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Optional
-
-from graphql import graphql
-
-from infrahub.core.branch import Branch
-from infrahub.core.constants import InfrahubKind
-from infrahub.core.manager import NodeManager
-from infrahub.core.protocols import CoreGraphQLQuery
-from infrahub.core.registry import registry
-from infrahub.core.timestamp import Timestamp
-from infrahub.graphql.initialization import prepare_graphql_params
-
-if TYPE_CHECKING:
-    from graphql.execution import ExecutionResult
-
-    from infrahub.database import InfrahubDatabase
-
-
-async def execute_query(
-    name: str,
-    db: InfrahubDatabase,
-    params: Optional[dict] = None,
-    branch: Branch | str | None = None,
-    at: Timestamp | str | None = None,
-) -> ExecutionResult:
-    """Helper function to Execute a GraphQL Query."""
-
-    if not isinstance(branch, Branch):
-        branch = await registry.get_branch(db=db, branch=branch)
-    at = Timestamp(at)
-
-    graphql_query = await NodeManager.get_one_by_default_filter(
-        db=db, id=name, kind=CoreGraphQLQuery, branch=branch, at=at
-    )
-    if not graphql_query:
-        raise ValueError(f"Unable to find the {InfrahubKind.GRAPHQLQUERY} {name}")
-
-    gql_params = await prepare_graphql_params(
-        branch=branch, db=db, at=at, include_mutation=False, include_subscription=False
-    )
-
-    result = await graphql(
-        schema=gql_params.schema,
-        source=graphql_query.query.value,
-        context_value=gql_params.context,
-        root_value=None,
-        variable_values=params or {},
-    )
-
-    return result

infrahub/message_bus/messages/check_repository_checkdefinition.py

@@ -1,20 +0,0 @@
-from pydantic import ConfigDict, Field
-
-from infrahub.message_bus import InfrahubMessage
-from infrahub.message_bus.types import ProposedChangeBranchDiff
-
-
-class CheckRepositoryCheckDefinition(InfrahubMessage):
-    """Triggers user defined checks to run based on a Check Definition."""
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    check_definition_id: str = Field(..., description="The unique ID of the check definition")
-    commit: str = Field(..., description="The commit to target")
-    repository_id: str = Field(..., description="The unique ID of the Repository")
-    repository_name: str = Field(..., description="The name of the Repository")
-    branch_name: str = Field(..., description="The branch where the check is run")
-    file_path: str = Field(..., description="The path and filename of the check")
-    class_name: str = Field(..., description="The name of the class containing the check")
-    proposed_change: str = Field(..., description="The unique ID of the Proposed Change")
-    branch_diff: ProposedChangeBranchDiff = Field(..., description="The calculated diff between the two branches")

infrahub/message_bus/messages/check_repository_mergeconflicts.py

@@ -1,16 +0,0 @@
-from pydantic import Field
-
-from infrahub.message_bus import InfrahubMessage
-
-
-class CheckRepositoryMergeConflicts(InfrahubMessage):
-    """Runs a check to validate if there are merge conflicts for a proposed change between two branches."""
-
-    validator_id: str = Field(..., description="The id of the validator associated with this check")
-    validator_execution_id: str = Field(..., description="The id of current execution of the associated validator")
-    check_execution_id: str = Field(..., description="The unique ID for the current execution of this check")
-    proposed_change: str = Field(..., description="The unique ID of the Proposed Change")
-    repository_id: str = Field(..., description="The unique ID of the Repository")
-    repository_name: str = Field(..., description="The name of the Repository")
-    source_branch: str = Field(..., description="The source branch")
-    target_branch: str = Field(..., description="The target branch")

infrahub/message_bus/messages/check_repository_usercheck.py

@@ -1,26 +0,0 @@
-from pydantic import ConfigDict, Field
-
-from infrahub.message_bus import InfrahubMessage
-from infrahub.message_bus.types import ProposedChangeBranchDiff
-
-
-class CheckRepositoryUserCheck(InfrahubMessage):
-    """Runs a check as defined within a CoreCheckDefinition within a repository."""
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    validator_id: str = Field(..., description="The id of the validator associated with this check")
-    validator_execution_id: str = Field(..., description="The id of current execution of the associated validator")
-    check_execution_id: str = Field(..., description="The unique ID for the current execution of this check")
-    check_definition_id: str = Field(..., description="The unique ID of the check definition")
-    commit: str = Field(..., description="The commit to target")
-    repository_id: str = Field(..., description="The unique ID of the Repository")
-    repository_name: str = Field(..., description="The name of the Repository")
-    branch_name: str = Field(..., description="The branch where the check is run")
-    file_path: str = Field(..., description="The path and filename of the check")
-    class_name: str = Field(..., description="The name of the class containing the check")
-    proposed_change: str = Field(..., description="The unique ID of the Proposed Change")
-    variables: dict = Field(default_factory=dict, description="Input variables when running the check")
-    name: str = Field(..., description="The name of the check")
-    branch_diff: ProposedChangeBranchDiff = Field(..., description="The calculated diff between the two branches")
-    timeout: int = Field(..., description="The timeout for the check")

infrahub/message_bus/messages/request_artifactdefinition_check.py

@@ -1,17 +0,0 @@
-from pydantic import ConfigDict, Field
-
-from infrahub.message_bus import InfrahubMessage
-from infrahub.message_bus.types import ProposedChangeArtifactDefinition, ProposedChangeBranchDiff
-
-
-class RequestArtifactDefinitionCheck(InfrahubMessage):
-    """Sent to validate the generation of artifacts in relation to a proposed change."""
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    artifact_definition: ProposedChangeArtifactDefinition = Field(..., description="The Artifact Definition")
-    branch_diff: ProposedChangeBranchDiff = Field(..., description="The calculated diff between the two branches")
-    proposed_change: str = Field(..., description="The unique ID of the Proposed Change")
-    source_branch: str = Field(..., description="The source branch")
-    source_branch_sync_with_git: bool = Field(..., description="Indicates if the source branch should sync with git")
-    destination_branch: str = Field(..., description="The target branch")

infrahub/message_bus/messages/request_repository_checks.py

@@ -1,12 +0,0 @@
-from pydantic import Field
-
-from infrahub.message_bus import InfrahubMessage
-
-
-class RequestRepositoryChecks(InfrahubMessage):
-    """Sent to trigger the checks for a repository to be executed."""
-
-    proposed_change: str = Field(..., description="The unique ID of the Proposed Change")
-    repository: str = Field(..., description="The unique ID of the Repository")
-    source_branch: str = Field(..., description="The source branch")
-    target_branch: str = Field(..., description="The target branch")

infrahub/message_bus/messages/request_repository_userchecks.py

@@ -1,18 +0,0 @@
-from pydantic import ConfigDict, Field
-
-from infrahub.message_bus import InfrahubMessage
-from infrahub.message_bus.types import ProposedChangeBranchDiff
-
-
-class RequestRepositoryUserChecks(InfrahubMessage):
-    """Sent to trigger the user defined checks on a repository."""
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    proposed_change: str = Field(..., description="The unique ID of the Proposed Change")
-    repository_id: str = Field(..., description="The unique ID of the Repository")
-    repository_name: str = Field(..., description="The name of the Repository")
-    source_branch: str = Field(..., description="The source branch")
-    source_branch_sync_with_git: bool = Field(..., description="Indicates if the source branch should sync with git")
-    target_branch: str = Field(..., description="The target branch")
-    branch_diff: ProposedChangeBranchDiff = Field(..., description="The calculated diff between the two branches")

infrahub/message_bus/operations/check/repository.py

@@ -1,293 +0,0 @@
-from infrahub_sdk.protocols import CoreCheckDefinition
-from infrahub_sdk.uuidt import UUIDT
-from prefect import flow
-from prefect.logging import get_run_logger
-
-from infrahub import lock
-from infrahub.core.constants import InfrahubKind
-from infrahub.core.manager import NodeManager
-from infrahub.core.timestamp import Timestamp
-from infrahub.exceptions import CheckError
-from infrahub.git.repository import InfrahubRepository
-from infrahub.message_bus import InfrahubMessage, messages
-from infrahub.message_bus.types import KVTTL
-from infrahub.services import InfrahubServices
-from infrahub.workflows.utils import add_tags
-
-
-@flow(
-    name="git-repository-check-definition",
-    flow_run_name="Run user defined checks for repository {message.repository_name}",
-)
-async def check_definition(message: messages.CheckRepositoryCheckDefinition, service: InfrahubServices) -> None:
-    await add_tags(branches=[message.branch_name], nodes=[message.proposed_change])
-    log = get_run_logger()
-
-    definition = await service.client.get(
-        kind=CoreCheckDefinition, id=message.check_definition_id, branch=message.branch_name
-    )
-    proposed_change = await service.client.get(kind=InfrahubKind.PROPOSEDCHANGE, id=message.proposed_change)
-    validator_execution_id = str(UUIDT())
-    check_execution_ids: list[str] = []
-    await proposed_change.validations.fetch()
-    validator = None
-    events: list[InfrahubMessage] = []
-
-    for relationship in proposed_change.validations.peers:
-        existing_validator = relationship.peer
-
-        if (
-            existing_validator.typename == InfrahubKind.USERVALIDATOR
-            and existing_validator.repository.id == message.repository_id
-            and existing_validator.check_definition.id == message.check_definition_id
-        ):
-            validator = existing_validator
-            service.log.info("Found the same validator", validator=validator)
-
-    if validator:
-        validator.conclusion.value = "unknown"
-        validator.state.value = "queued"
-        validator.started_at.value = ""
-        validator.completed_at.value = ""
-        await validator.save()
-    else:
-        validator = await service.client.create(
-            kind=InfrahubKind.USERVALIDATOR,
-            data={
-                "label": f"Check: {definition.name.value}",
-                "proposed_change": message.proposed_change,
-                "repository": message.repository_id,
-                "check_definition": message.check_definition_id,
-            },
-        )
-        await validator.save()
-
-    if definition.targets.id:
-        # Check against a group of targets
-        await definition.targets.fetch()
-        group = definition.targets.peer
-        await group.members.fetch()
-        for relationship in group.members.peers:
-            member = relationship.peer
-
-            check_execution_id = str(UUIDT())
-            check_execution_ids.append(check_execution_id)
-            events.append(
-                messages.CheckRepositoryUserCheck(
-                    name=member.display_label,
-                    validator_id=validator.id,
-                    validator_execution_id=validator_execution_id,
-                    check_execution_id=check_execution_id,
-                    repository_id=message.repository_id,
-                    repository_name=message.repository_name,
-                    commit=message.commit,
-                    file_path=message.file_path,
-                    class_name=message.class_name,
-                    branch_name=message.branch_name,
-                    check_definition_id=message.check_definition_id,
-                    proposed_change=message.proposed_change,
-                    variables=member.extract(params=definition.parameters.value),
-                    branch_diff=message.branch_diff,
-                    timeout=definition.timeout.value,
-                )
-            )
-
-    else:
-        check_execution_id = str(UUIDT())
-        check_execution_ids.append(check_execution_id)
-        events.append(
-            messages.CheckRepositoryUserCheck(
-                name=definition.name.value,
-                validator_id=validator.id,
-                validator_execution_id=validator_execution_id,
-                check_execution_id=check_execution_id,
-                repository_id=message.repository_id,
-                repository_name=message.repository_name,
-                commit=message.commit,
-                file_path=message.file_path,
-                class_name=message.class_name,
-                branch_name=message.branch_name,
-                check_definition_id=message.check_definition_id,
-                proposed_change=message.proposed_change,
-                branch_diff=message.branch_diff,
-                timeout=definition.timeout.value,
-            )
-        )
-
-    checks_in_execution = ",".join(check_execution_ids)
-    log.info(f"Checks in execution {checks_in_execution}")
-    await service.cache.set(
-        key=f"validator_execution_id:{validator_execution_id}:checks",
-        value=checks_in_execution,
-        expires=KVTTL.TWO_HOURS,
-    )
-    events.append(
-        messages.FinalizeValidatorExecution(
-            start_time=Timestamp().to_string(),
-            validator_id=validator.id,
-            validator_execution_id=validator_execution_id,
-            validator_type=InfrahubKind.USERVALIDATOR,
-        )
-    )
-
-    for event in events:
-        event.assign_meta(parent=message)
-        await service.send(message=event)
-
-
-@flow(
-    name="git-repository-check-merge-conflict",
-    flow_run_name="Check for merge conflicts between {message.source_branch} and {message.target_branch}",
-)
-async def merge_conflicts(message: messages.CheckRepositoryMergeConflicts, service: InfrahubServices) -> None:
-    """Runs a check to see if there are merge conflicts between two branches."""
-    await add_tags(branches=[message.source_branch], nodes=[message.proposed_change])
-
-    success_condition = "-"
-    validator = await service.client.get(kind=InfrahubKind.REPOSITORYVALIDATOR, id=message.validator_id)
-    await validator.checks.fetch()
-
-    repo = await InfrahubRepository.init(id=message.repository_id, name=message.repository_name, service=service)
-    async with lock.registry.get(name=message.repository_name, namespace="repository"):
-        conflicts = await repo.get_conflicts(source_branch=message.source_branch, dest_branch=message.target_branch)
-
-    existing_checks = {}
-    for relationship in validator.checks.peers:
-        existing_check = relationship.peer
-        if existing_check.typename == InfrahubKind.FILECHECK and existing_check.kind.value == "MergeConflictCheck":
-            check_key = ""
-            if existing_check.files.value:
-                check_key = "".join(existing_check.files.value)
-            check_key = f"-{check_key}"
-            existing_checks[check_key] = existing_check
-
-    validator_conclusion = "success"
-    check = None
-    if conflicts:
-        validator_conclusion = "failure"
-        for conflict in conflicts:
-            conflict_key = f"-{conflict}"
-            if conflict_key in existing_checks:
-                existing_checks[conflict_key].created_at.value = Timestamp().to_string()
-                await existing_checks[conflict_key].save()
-                existing_checks.pop(conflict_key)
-            else:
-                check = await service.client.create(
-                    kind=InfrahubKind.FILECHECK,
-                    data={
-                        "name": conflict,
-                        "origin": "ConflictCheck",
-                        "kind": "MergeConflictCheck",
-                        "validator": message.validator_id,
-                        "created_at": Timestamp().to_string(),
-                        "files": [conflict],
-                        "conclusion": "failure",
-                        "severity": "critical",
-                    },
-                )
-                await check.save()
-
-    elif success_condition in existing_checks:
-        existing_checks[success_condition].created_at.value = Timestamp().to_string()
-        await existing_checks[success_condition].save()
-        existing_checks.pop(success_condition)
-
-    else:
-        check = await service.client.create(
-            kind=InfrahubKind.FILECHECK,
-            data={
-                "name": "Merge Conflict Check",
-                "origin": "ConflictCheck",
-                "kind": "MergeConflictCheck",
-                "validator": message.validator_id,
-                "created_at": Timestamp().to_string(),
-                "conclusion": "success",
-                "severity": "info",
-            },
-        )
-        await check.save()
-
-    async with service.database.start_session() as db:
-        await NodeManager.delete(db=db, nodes=list(existing_checks.values()))
-
-    await service.cache.set(
-        key=f"validator_execution_id:{message.validator_execution_id}:check_execution_id:{message.check_execution_id}",
-        value=validator_conclusion,
-        expires=KVTTL.TWO_HOURS,
-    )
-
-
-@flow(name="git-repository-user-check", flow_run_name="Execute user defined Check '{message.name}'")
-async def user_check(message: messages.CheckRepositoryUserCheck, service: InfrahubServices) -> None:
-    await add_tags(branches=[message.branch_name], nodes=[message.proposed_change])
-    log = get_run_logger()
-
-    validator = await service.client.get(kind=InfrahubKind.USERVALIDATOR, id=message.validator_id)
-    await validator.checks.fetch()
-
-    repo = await InfrahubRepository.init(
-        id=message.repository_id, name=message.repository_name, commit=message.commit, service=service
-    )
-    conclusion = "failure"
-    severity = "critical"
-    log_entries = ""
-    try:
-        check_run = await repo.execute_python_check.with_options(timeout_seconds=message.timeout)(
-            branch_name=message.branch_name,
-            location=message.file_path,
-            class_name=message.class_name,
-            client=service.client,
-            commit=message.commit,
-            params=message.variables,
-        )
-        if check_run.passed:
-            conclusion = "success"
-            severity = "info"
-            log.info("The check passed")
-        else:
-            log.warning("The check reported failures")
-            for log_entry in check_run.log_entries:
-                log.warning(log_entry)
-        log_entries = check_run.log_entries
-    except CheckError as exc:
-        log.warning("The check failed to run")
-        log.error(exc.message)
-        log_entries = f"FATAL Error/n:{exc.message}"
-
-    check = None
-    for relationship in validator.checks.peers:
-        existing_check = relationship.peer
-        if (
-            existing_check.typename == InfrahubKind.STANDARDCHECK
-            and existing_check.kind.value == "CheckDefinition"
-            and existing_check.name.value == message.name
-        ):
-            check = existing_check
-
-    if check:
-        check.created_at.value = Timestamp().to_string()
-        check.message.value = log_entries
-        check.conclusion.value = conclusion
-        check.severity.value = severity
-        await check.save()
-    else:
-        check = await service.client.create(
-            kind=InfrahubKind.STANDARDCHECK,
-            data={
-                "name": message.name,
-                "origin": message.repository_id,
-                "kind": "CheckDefinition",
-                "validator": message.validator_id,
-                "created_at": Timestamp().to_string(),
-                "message": log_entries,
-                "conclusion": conclusion,
-                "severity": severity,
-            },
-        )
-        await check.save()
-
-    await service.cache.set(
-        key=f"validator_execution_id:{message.validator_execution_id}:check_execution_id:{message.check_execution_id}",
-        value=conclusion,
-        expires=KVTTL.TWO_HOURS,
-    )

infrahub/message_bus/operations/requests/artifact_definition.py

@@ -1,148 +0,0 @@
-from typing import Optional
-
-from infrahub_sdk.uuidt import UUIDT
-from prefect import flow
-from prefect.logging import get_run_logger
-
-from infrahub.core.constants import InfrahubKind, ValidatorConclusion, ValidatorState
-from infrahub.core.timestamp import Timestamp
-from infrahub.message_bus import InfrahubMessage, Meta, messages
-from infrahub.message_bus.types import KVTTL
-from infrahub.services import InfrahubServices
-from infrahub.workflows.utils import add_tags
-
-
-@flow(
-    name="artifact-definition-check",
-    flow_run_name="Validating generation of artifacts for {message.artifact_definition.definition_name}",
-)
-async def check(message: messages.RequestArtifactDefinitionCheck, service: InfrahubServices) -> None:
-    events: list[InfrahubMessage] = []
-    await add_tags(branches=[message.source_branch], nodes=[message.proposed_change], db_change=True)
-
-    log = get_run_logger()
-    artifact_definition = await service.client.get(
-        kind=InfrahubKind.ARTIFACTDEFINITION,
-        id=message.artifact_definition.definition_id,
-        branch=message.source_branch,
-    )
-    proposed_change = await service.client.get(kind=InfrahubKind.PROPOSEDCHANGE, id=message.proposed_change)
-
-    validator_name = f"Artifact Validator: {message.artifact_definition.definition_name}"
-    validator_execution_id = str(UUIDT())
-    check_execution_ids: list[str] = []
-
-    await proposed_change.validations.fetch()
-
-    validator = None
-    for relationship in proposed_change.validations.peers:
-        existing_validator = relationship.peer
-        if (
-            existing_validator.typename == InfrahubKind.ARTIFACTVALIDATOR
-            and existing_validator.definition.id == message.artifact_definition.definition_id
-        ):
-            validator = existing_validator
-
-    if validator:
-        validator.conclusion.value = ValidatorConclusion.UNKNOWN.value
-        validator.state.value = ValidatorState.QUEUED.value
-        validator.started_at.value = ""
-        validator.completed_at.value = ""
-        await validator.save()
-    else:
-        validator = await service.client.create(
-            kind=InfrahubKind.ARTIFACTVALIDATOR,
-            data={
-                "label": validator_name,
-                "proposed_change": message.proposed_change,
-                "definition": message.artifact_definition.definition_id,
-            },
-        )
-        await validator.save()
-
-    await artifact_definition.targets.fetch()
-    group = artifact_definition.targets.peer
-    await group.members.fetch()
-
-    existing_artifacts = await service.client.filters(
-        kind=InfrahubKind.ARTIFACT,
-        definition__ids=[message.artifact_definition.definition_id],
-        include=["object"],
-        branch=message.source_branch,
-    )
-    artifacts_by_member = {}
-    for artifact in existing_artifacts:
-        artifacts_by_member[artifact.object.peer.id] = artifact.id
-
-    repository = message.branch_diff.get_repository(repository_id=message.artifact_definition.repository_id)
-    requested_artifacts = 0
-    impacted_artifacts = message.branch_diff.get_subscribers_ids(kind=InfrahubKind.ARTIFACT)
-    for relationship in group.members.peers:
-        member = relationship.peer
-        artifact_id = artifacts_by_member.get(member.id)
-        if _render_artifact(
-            artifact_id=artifact_id,
-            managed_branch=message.source_branch_sync_with_git,
-            impacted_artifacts=impacted_artifacts,
-        ):
-            check_execution_id = str(UUIDT())
-            check_execution_ids.append(check_execution_id)
-            requested_artifacts += 1
-            log.info(f"Trigger Artifact processing for {member.display_label}")
-            events.append(
-                messages.CheckArtifactCreate(
-                    artifact_name=message.artifact_definition.artifact_name,
-                    artifact_id=artifact_id,
-                    artifact_definition=message.artifact_definition.definition_id,
-                    commit=repository.source_commit,
-                    content_type=message.artifact_definition.content_type,
-                    transform_type=message.artifact_definition.transform_kind,
-                    transform_location=message.artifact_definition.transform_location,
-                    repository_id=repository.repository_id,
-                    repository_name=repository.repository_name,
-                    repository_kind=repository.kind,
-                    branch_name=message.source_branch,
-                    query=message.artifact_definition.query_name,
-                    variables=member.extract(params=artifact_definition.parameters.value),
-                    target_id=member.id,
-                    target_name=member.display_label,
-                    timeout=message.artifact_definition.timeout,
-                    validator_id=validator.id,
-                    meta=Meta(validator_execution_id=validator_execution_id, check_execution_id=check_execution_id),
-                )
-            )
-
-    checks_in_execution = ",".join(check_execution_ids)
-    await service.cache.set(
-        key=f"validator_execution_id:{validator_execution_id}:checks",
-        value=checks_in_execution,
-        expires=KVTTL.TWO_HOURS,
-    )
-    events.append(
-        messages.FinalizeValidatorExecution(
-            start_time=Timestamp().to_string(),
-            validator_id=validator.id,
-            validator_execution_id=validator_execution_id,
-            validator_type=InfrahubKind.ARTIFACTVALIDATOR,
-        )
-    )
-    for event in events:
-        event.assign_meta(parent=message)
-        await service.send(message=event)
-
-
-def _render_artifact(artifact_id: Optional[str], managed_branch: bool, impacted_artifacts: list[str]) -> bool:  # pylint: disable=unused-argument
-    """Returns a boolean to indicate if an artifact should be generated or not.
-    Will return true if:
-        * The artifact_id wasn't set which could be that it's a new object that doesn't have a previous artifact
-        * The source brance is not data only which would indicate that it could contain updates in git to the transform
-        * The artifact_id exists in the impacted_artifacts list
-    Will return false if:
-        * The source branch is a data only branch and the artifact_id exists and is not in the impacted list
-    """
-
-    # if not artifact_id or managed_branch:
-    #    return True
-    # return artifact_id in impacted_artifacts
-    # Temporary workaround tracked in https://github.com/opsmill/infrahub/issues/4991
-    return True