infrahub-server 1.1.9__py3-none-any.whl → 1.2.0__py3-none-any.whl

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

infrahub/message_bus/operations/requests/repository.py

@@ -1,133 +0,0 @@
-from infrahub_sdk.uuidt import UUIDT
-from prefect import flow
-from prefect.logging import get_run_logger
-
-from infrahub.core.constants import InfrahubKind
-from infrahub.core.timestamp import Timestamp
-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="repository-check", flow_run_name="Running repository checks for repository {message.repository}")
-async def checks(message: messages.RequestRepositoryChecks, service: InfrahubServices) -> None:
-    """Request to start validation checks on a specific repository."""
-    await add_tags(branches=[message.source_branch], nodes=[message.proposed_change])
-    log = get_run_logger()
-
-    events: list[InfrahubMessage] = []
-
-    repository = await service.client.get(
-        kind=InfrahubKind.GENERICREPOSITORY, id=message.repository, branch=message.source_branch
-    )
-    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()
-    await repository.checks.fetch()
-
-    validator_name = f"Repository Validator: {repository.name.value}"
-    validator = None
-    for relationship in proposed_change.validations.peers:
-        existing_validator = relationship.peer
-
-        if (
-            existing_validator.typename == InfrahubKind.REPOSITORYVALIDATOR
-            and existing_validator.repository.id == message.repository
-        ):
-            validator = existing_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.REPOSITORYVALIDATOR,
-            data={
-                "label": validator_name,
-                "proposed_change": message.proposed_change,
-                "repository": message.repository,
-            },
-        )
-        await validator.save()
-
-    check_execution_id = str(UUIDT())
-    check_execution_ids.append(check_execution_id)
-    log.info("Adding check for merge conflict")
-
-    events.append(
-        messages.CheckRepositoryMergeConflicts(
-            validator_id=validator.id,
-            validator_execution_id=validator_execution_id,
-            check_execution_id=check_execution_id,
-            proposed_change=message.proposed_change,
-            repository_id=message.repository,
-            repository_name=repository.name.value,
-            source_branch=message.source_branch,
-            target_branch=message.target_branch,
-        )
-    )
-
-    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.REPOSITORYVALIDATOR,
-        )
-    )
-
-    for event in events:
-        event.assign_meta(parent=message)
-        await service.send(message=event)
-
-
-@flow(
-    name="repository-users-check",
-    flow_run_name="Evaluating user-defined checks on repository {message.repository_name}",
-)
-async def user_checks(message: messages.RequestRepositoryUserChecks, service: InfrahubServices) -> None:
-    """Request to start validation checks on a specific repository for User-defined checks."""
-
-    await add_tags(branches=[message.source_branch], nodes=[message.proposed_change])
-    log = get_run_logger()
-
-    events: list[InfrahubMessage] = []
-
-    repository = await service.client.get(
-        kind=InfrahubKind.GENERICREPOSITORY, id=message.repository_id, branch=message.source_branch, fragment=True
-    )
-    await repository.checks.fetch()
-
-    for relationship in repository.checks.peers:
-        log.info("Adding check for user defined check")
-        check_definition = relationship.peer
-        events.append(
-            messages.CheckRepositoryCheckDefinition(
-                check_definition_id=check_definition.id,
-                repository_id=repository.id,
-                repository_name=repository.name.value,
-                commit=repository.commit.value,
-                file_path=check_definition.file_path.value,
-                class_name=check_definition.class_name.value,
-                branch_name=message.source_branch,
-                proposed_change=message.proposed_change,
-                branch_diff=message.branch_diff,
-            )
-        )
-
-    for event in events:
-        event.assign_meta(parent=message)
-        await service.send(message=event)

infrahub/schema/constants.py

@@ -1 +0,0 @@
-AUTOMATION_NAME = "Trigger-schema-update-event"

infrahub/schema/tasks.py

@@ -1,76 +0,0 @@
-from __future__ import annotations
-
-from datetime import timedelta
-
-from prefect import flow
-from prefect.automations import AutomationCore
-from prefect.client.orchestration import get_client
-from prefect.client.schemas.filters import DeploymentFilter, DeploymentFilterName
-from prefect.events.actions import RunDeployment
-from prefect.events.schemas.automations import EventTrigger, Posture
-from prefect.logging import get_run_logger
-
-from infrahub.workflows.catalogue import COMPUTED_ATTRIBUTE_SETUP, COMPUTED_ATTRIBUTE_SETUP_PYTHON
-
-from .constants import AUTOMATION_NAME
-
-
-@flow(name="schema-updated-setup", flow_run_name="Setup schema updated event in task-manager")
-async def schema_updated_setup() -> None:
-    log = get_run_logger()
-
-    async with get_client(sync_client=False) as client:
-        deployments = {
-            item.name: item
-            for item in await client.read_deployments(
-                deployment_filter=DeploymentFilter(
-                    name=DeploymentFilterName(
-                        any_=[COMPUTED_ATTRIBUTE_SETUP.name, COMPUTED_ATTRIBUTE_SETUP_PYTHON.name]
-                    )
-                )
-            )
-        }
-        if COMPUTED_ATTRIBUTE_SETUP.name not in deployments:
-            raise ValueError("Unable to find the deployment for PROCESS_COMPUTED_MACRO")
-
-        deployment_id_computed_attribute_setup = deployments[COMPUTED_ATTRIBUTE_SETUP.name].id
-        deployment_id_computed_attribute_setup_python = deployments[COMPUTED_ATTRIBUTE_SETUP_PYTHON.name].id
-
-        schema_update_automation = await client.find_automation(id_or_name=AUTOMATION_NAME)
-
-        automation = AutomationCore(
-            name=AUTOMATION_NAME,
-            description="Trigger actions on schema update event",
-            enabled=True,
-            trigger=EventTrigger(
-                posture=Posture.Reactive,
-                expect={"infrahub.schema.update"},
-                within=timedelta(0),
-                threshold=1,
-            ),
-            actions=[
-                RunDeployment(
-                    source="selected",
-                    deployment_id=deployment_id_computed_attribute_setup,
-                    parameters={
-                        "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
-                    },
-                    job_variables={},
-                ),
-                RunDeployment(
-                    source="selected",
-                    deployment_id=deployment_id_computed_attribute_setup_python,
-                    parameters={
-                        "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
-                    },
-                    job_variables={},
-                ),
-            ],
-        )
-
-        if schema_update_automation:
-            await client.update_automation(automation_id=schema_update_automation.id, automation=automation)
-            log.info(f"{AUTOMATION_NAME} Updated")
-        else:
-            await client.create_automation(automation=automation)
-            log.info(f"{AUTOMATION_NAME} Created")

infrahub/services/adapters/database/__init__.py

@@ -1,9 +0,0 @@
-from neo4j import AsyncSession
-
-
-class InfrahubDatabase:
-    """Base class for database access"""
-
-    @property
-    def session(self) -> AsyncSession:
-        raise NotImplementedError()

infrahub/tasks/telemetry.py

@@ -1,127 +0,0 @@
-import hashlib
-import json
-import platform
-import time
-from typing import Any
-
-from prefect import flow, task
-from prefect.cache_policies import NONE
-from prefect.logging import get_run_logger
-
-from infrahub import __version__, config
-from infrahub.core import registry, utils
-from infrahub.core.branch import Branch
-from infrahub.core.constants import InfrahubKind
-from infrahub.core.graph.schema import GRAPH_SCHEMA
-from infrahub.services import InfrahubServices, services
-
-TELEMETRY_KIND: str = "community"
-TELEMETRY_VERSION: str = "20240524"
-
-
-@task(name="telemetry-gather-db", task_run_name="Gather Database Information", cache_policy=NONE)
-async def gather_database_information(service: InfrahubServices, branch: Branch) -> dict:  # pylint: disable=unused-argument
-    async with service.database.start_session() as db:
-        data: dict[str, Any] = {
-            "database_type": db.db_type.value,
-            "relationship_count": {"total": await utils.count_relationships(db=db)},
-            "node_count": {"total": await utils.count_nodes(db=db)},
-        }
-
-        for name in GRAPH_SCHEMA["relationships"]:
-            data["relationship_count"][name] = await utils.count_relationships(db=db, label=name)
-
-        for name in GRAPH_SCHEMA["nodes"]:
-            data["node_count"][name] = await utils.count_nodes(db=db, label=name)
-
-        return data
-
-
-@task(name="telemetry-schema-information", task_run_name="Gather Schema Information", cache_policy=NONE)
-async def gather_schema_information(service: InfrahubServices, branch: Branch) -> dict:  # pylint: disable=unused-argument
-    data: dict[str, Any] = {}
-    main_schema = registry.schema.get_schema_branch(name=branch.name)
-    data["node_count"] = len(main_schema.node_names)
-    data["generic_count"] = len(main_schema.generic_names)
-    data["last_update"] = branch.schema_changed_at
-
-    return data
-
-
-@task(name="telemetry-feature-information", task_run_name="Gather Feature Information", cache_policy=NONE)
-async def gather_feature_information(service: InfrahubServices, branch: Branch) -> dict:  # pylint: disable=unused-argument
-    async with service.database.start_session() as db:
-        data = {}
-        features_to_count = [
-            InfrahubKind.ARTIFACT,
-            InfrahubKind.RESOURCEPOOL,
-            InfrahubKind.REPOSITORY,
-            InfrahubKind.GENERICGROUP,
-            InfrahubKind.PROFILE,
-            InfrahubKind.PROPOSEDCHANGE,
-            InfrahubKind.TRANSFORM,
-        ]
-        for kind in features_to_count:
-            data[kind] = await utils.count_nodes(db=db, label=kind)
-
-        return data
-
-
-@task(name="telemetry-gather-data", task_run_name="Gather Anonynous Data", cache_policy=NONE)
-async def gather_anonymous_telemetry_data(service: InfrahubServices) -> dict:
-    start_time = time.time()
-
-    default_branch = registry.get_branch_from_registry()
-    workers = await service.component.list_workers(branch=default_branch.name, schema_hash=False)
-
-    data: dict[str, Any] = {
-        "deployment_id": registry.id,
-        "execution_time": None,
-        "infrahub_version": __version__,
-        "python_version": platform.python_version(),
-        "platform": platform.machine(),
-        "workers": {
-            "total": len(workers),
-            "active": len([w for w in workers if w.active]),
-        },
-        "branches": {
-            "total": len(registry.branch),
-        },
-        "features": await gather_feature_information(service=service, branch=default_branch),
-        "schema": await gather_schema_information(service=service, branch=default_branch),
-        "database": await gather_database_information(service=service, branch=default_branch),
-    }
-
-    data["execution_time"] = time.time() - start_time
-
-    return data
-
-
-@task(name="telemetry-post-data", task_run_name="Upload data", retries=5, cache_policy=NONE)
-async def post_telemetry_data(service: InfrahubServices, url: str, payload: dict[str, Any]) -> None:
-    """Send the telemetry data to the specified URL, using HTTP POST."""
-    response = await service.http.post(url=url, json=payload)
-    response.raise_for_status()
-
-
-@flow(name="anonymous_telemetry_send", flow_run_name="Send anonymous telemetry")
-async def send_telemetry_push() -> None:
-    service = services.service
-    log = get_run_logger()
-    if config.SETTINGS.main.telemetry_optout:
-        log.info("Skipping, User opted out of this service.")
-        return
-
-    log.info(f"Pushing anonymous telemetry data to {config.SETTINGS.main.telemetry_endpoint}...")
-
-    data = await gather_anonymous_telemetry_data(service=service)
-    log.info(f"Anonymous usage telemetry gathered in {data['execution_time']} seconds. | {data}")
-
-    payload = {
-        "kind": TELEMETRY_KIND,
-        "payload_format": TELEMETRY_VERSION,
-        "data": data,
-        "checksum": hashlib.sha256(json.dumps(data).encode()).hexdigest(),
-    }
-
-    await post_telemetry_data(service=service, url=config.SETTINGS.main.telemetry_endpoint, payload=payload)

infrahub/webhook/constants.py

@@ -1,3 +0,0 @@
-AUTOMATION_NAME = "Trigger-webhook-update-configuration"
-
-AUTOMATION_NAME_RUN = "Trigger-webhook-execution"