qontract-reconcile 0.10.2.dev221__tar.gz → 0.10.2.dev222__tar.gz

{qontract_reconcile-0.10.2.dev221 → qontract_reconcile-0.10.2.dev222}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qontract-reconcile
-Version: 0.10.2.dev221
+Version: 0.10.2.dev222
 Summary: Collection of tools to reconcile services with their desired state as defined in the app-interface DB.
 Project-URL: homepage, https://github.com/app-sre/qontract-reconcile
 Project-URL: repository, https://github.com/app-sre/qontract-reconcile
@@ -131,8 +131,6 @@ OpenShift templates can be found [here](/openshift/qontract-reconcile.yaml). In
                                   RHIDP.
   cluster-deployment-mapper       Maps ClusterDeployment resources to Cluster
                                   IDs.
-  cna-resources                   Manage Cloud Resources using Cloud Native
-                                  Assets (CNA).
   dashdotdb-cso                   Collects the ImageManifestVuln CRs from all
                                   the clusters and posts them to Dashdotdb.
   dashdotdb-dora                  Collects dora metrics.

{qontract_reconcile-0.10.2.dev221 → qontract_reconcile-0.10.2.dev222}/README.md

@@ -66,8 +66,6 @@ OpenShift templates can be found [here](/openshift/qontract-reconcile.yaml). In
                                   RHIDP.
   cluster-deployment-mapper       Maps ClusterDeployment resources to Cluster
                                   IDs.
-  cna-resources                   Manage Cloud Resources using Cloud Native
-                                  Assets (CNA).
   dashdotdb-cso                   Collects the ImageManifestVuln CRs from all
                                   the clusters and posts them to Dashdotdb.
   dashdotdb-dora                  Collects dora metrics.

{qontract_reconcile-0.10.2.dev221 → qontract_reconcile-0.10.2.dev222}/reconcile/cli.py

@@ -2414,27 +2414,6 @@ def terraform_cloudflare_users(
     )
 
 
-@integration.command(
-    short_help="Manage Cloud Resources using Cloud Native Assets (CNA)."
-)
-@enable_deletion(default=False)
-@threaded()
-@click.pass_context
-def cna_resources(
-    ctx: click.Context,
-    enable_deletion: bool,
-    thread_pool_size: int,
-) -> None:
-    import reconcile.cna.integration
-
-    run_integration(
-        reconcile.cna.integration,
-        ctx,
-        enable_deletion,
-        thread_pool_size,
-    )
-
-
 @integration.command(short_help="Manage auto-promotions defined in SaaS files")
 @threaded()
 @click.option("--env-name", default=None, help="environment to filter saas files by")

qontract_reconcile-0.10.2.dev221/reconcile/cna/assets/asset.py

@@ -1,43 +0,0 @@
-from __future__ import annotations
-
-from abc import (
-    ABC,
-    abstractmethod,
-)
-from dataclasses import (
-    dataclass,
-    field,
-)
-from enum import Enum
-from typing import Any
-
-
-class AssetError(Exception):
-    pass
-
-
-class AssetType(Enum):
-    NULL = "null"
-
-
-class AssetStatus(Enum):
-    TERMINATED = "Terminated"
-    PENDING = "Pending"
-    RUNNING = "Running"
-
-
-@dataclass(frozen=True)
-class Asset(ABC):
-    uuid: str | None = field(compare=False, hash=True)
-    href: str | None = field(compare=False, hash=True)
-    status: AssetStatus | None = field(compare=False, hash=True)
-    name: str
-    kind: AssetType
-
-    @abstractmethod
-    def api_payload(self) -> dict[str, Any]:
-        raise NotImplementedError()
-
-    @abstractmethod
-    def update_from(self, asset: Asset) -> Asset:
-        raise NotImplementedError()

qontract_reconcile-0.10.2.dev221/reconcile/cna/assets/asset_factory.py

@@ -1,25 +0,0 @@
-from collections.abc import Mapping
-from typing import Any
-
-from reconcile.cna.assets.asset import (
-    Asset,
-    AssetError,
-)
-from reconcile.cna.assets.null import NullAsset
-from reconcile.gql_definitions.cna.queries.cna_resources import (
-    CNANullAssetV1,
-    CNAssetV1,
-)
-
-
-def asset_factory_from_schema(schema_asset: CNAssetV1) -> Asset:
-    if isinstance(schema_asset, CNANullAssetV1):
-        return NullAsset.from_query_class(schema_asset)
-    raise AssetError(f"Unknown schema asset type {schema_asset}")
-
-
-def asset_factory_from_raw_data(data_asset: Mapping[str, Any]) -> Asset:
-    asset_type = data_asset.get("asset_type")
-    if asset_type == "null":
-        return NullAsset.from_api_mapping(data_asset)
-    raise AssetError(f"Unknown data asset type {data_asset}")

qontract_reconcile-0.10.2.dev221/reconcile/cna/assets/null.py

@@ -1,61 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Mapping
-from dataclasses import dataclass
-from typing import Any
-
-from reconcile.cna.assets.asset import (
-    Asset,
-    AssetError,
-    AssetStatus,
-    AssetType,
-)
-from reconcile.gql_definitions.cna.queries.cna_resources import CNANullAssetV1
-
-
-@dataclass(frozen=True)
-class NullAsset(Asset):
-    addr_block: str | None
-
-    def api_payload(self) -> dict[str, Any]:
-        return {
-            "asset_type": "null",
-            "name": self.name,
-            "parameters": {
-                "addr_block": self.addr_block,
-            },
-        }
-
-    def update_from(self, asset: Asset) -> Asset:
-        if not isinstance(asset, NullAsset):
-            raise AssetError(f"Cannot create NullAsset from {asset}")
-        return NullAsset(
-            uuid=self.uuid,
-            href=self.href,
-            status=self.status,
-            name=self.name,
-            kind=self.kind,
-            addr_block=asset.addr_block,
-        )
-
-    @staticmethod
-    def from_query_class(asset: CNANullAssetV1) -> NullAsset:
-        return NullAsset(
-            uuid=None,
-            href=None,
-            status=None,
-            kind=AssetType.NULL,
-            name=asset.name,
-            addr_block=asset.addr_block,
-        )
-
-    @staticmethod
-    def from_api_mapping(asset: Mapping[str, Any]) -> NullAsset:
-        return NullAsset(
-            uuid=asset.get("id"),
-            href=asset.get("href"),
-            status=AssetStatus(asset.get("status")),
-            kind=AssetType.NULL,
-            name=asset.get("name", ""),
-            addr_block=asset.get("addr_block"),
-        )

qontract_reconcile-0.10.2.dev221/reconcile/cna/client.py

@@ -1,52 +0,0 @@
-import logging
-from typing import Any
-
-from reconcile.cna.assets.asset import Asset
-from reconcile.utils.ocm_base_client import OCMBaseClient
-
-
-class CNAClient:
-    """
-    Client used to interact with CNA. CNA API doc can be found here:
-    https://gitlab.cee.redhat.com/service/cna-management/-/blob/main/openapi/openapi.yaml#/
-    """
-
-    def __init__(self, ocm_client: OCMBaseClient):
-        self._ocm_client = ocm_client
-
-    def list_assets(self) -> list[dict[str, Any]]:
-        """
-        We use this to fetch the current real-world state
-        of our assets
-        """
-        # TODO: properly handle paging
-        cnas = self._ocm_client.get(api_path="/api/cna-management/v1/cnas")
-        return cnas.get("items", [])
-
-    def create(self, asset: Asset, dry_run: bool = False) -> None:
-        if dry_run:
-            logging.info("CREATE %s", asset)
-            return
-        self._ocm_client.post(
-            api_path="/api/cna-management/v1/cnas",
-            data=asset.api_payload(),
-        )
-
-    def delete(self, asset: Asset, dry_run: bool = False) -> None:
-        if dry_run:
-            logging.info("DELETE %s", asset)
-            return
-        if asset.href:
-            self._ocm_client.delete(
-                api_path=asset.href,
-            )
-
-    def update(self, asset: Asset, dry_run: bool = False) -> None:
-        if dry_run:
-            logging.info("UPDATE %s", asset)
-            return
-        if asset.href:
-            self._ocm_client.patch(
-                api_path=asset.href,
-                data=asset.api_payload(),
-            )

qontract_reconcile-0.10.2.dev221/reconcile/cna/integration.py

@@ -1,137 +0,0 @@
-from collections import defaultdict
-from collections.abc import (
-    Iterable,
-    Mapping,
-)
-
-from reconcile.cna.assets.asset_factory import asset_factory_from_schema
-from reconcile.cna.client import CNAClient
-from reconcile.cna.state import State
-from reconcile.gql_definitions.cna.queries.cna_provisioners import (
-    CNAExperimentalProvisionerV1,
-)
-from reconcile.gql_definitions.cna.queries.cna_provisioners import (
-    query as cna_provisioners_query,
-)
-from reconcile.gql_definitions.cna.queries.cna_resources import (
-    NamespaceCNAssetV1,
-    NamespaceV1,
-)
-from reconcile.gql_definitions.cna.queries.cna_resources import (
-    query as namespaces_query,
-)
-from reconcile.typed_queries.app_interface_vault_settings import (
-    get_app_interface_vault_settings,
-)
-from reconcile.utils import gql
-from reconcile.utils.ocm_base_client import OCMBaseClient
-from reconcile.utils.secret_reader import (
-    SecretReaderBase,
-    create_secret_reader,
-)
-from reconcile.utils.semver_helper import make_semver
-
-QONTRACT_INTEGRATION = "cna_resources"
-QONTRACT_INTEGRATION_VERSION = make_semver(0, 1, 0)
-
-
-class CNAConfigException(Exception):
-    pass
-
-
-class CNAIntegration:
-    def __init__(
-        self,
-        cna_clients: Mapping[str, CNAClient],
-        namespaces: Iterable[NamespaceV1],
-        desired_states: Mapping[str, State] | None = None,
-        current_states: Mapping[str, State] | None = None,
-    ) -> None:
-        self._cna_clients = cna_clients
-        self._namespaces = namespaces
-        self._desired_states = desired_states or defaultdict(State)
-        self._current_states = current_states or defaultdict(State)
-
-    def assemble_desired_states(self) -> None:
-        self._desired_states = defaultdict(State)
-        for namespace in self._namespaces:
-            for provider in namespace.external_resources or []:
-                # TODO: this should probably be filtered within the query already
-                if not isinstance(provider, NamespaceCNAssetV1):
-                    continue
-                for resource in provider.resources or []:
-                    self._desired_states[provider.provisioner.name].add_asset(
-                        asset_factory_from_schema(resource)
-                    )
-
-    def assemble_current_states(self) -> None:
-        self._current_states = defaultdict(State)
-        for name, client in self._cna_clients.items():
-            cnas = client.list_assets()
-            state = State()
-            state.add_raw_data(cnas)
-            self._current_states[name] = state
-
-    def provision(self, dry_run: bool = False) -> None:
-        for provisioner_name, cna_client in self._cna_clients.items():
-            desired_state = self._desired_states[provisioner_name]
-            current_state = self._current_states[provisioner_name]
-
-            additions = desired_state - current_state
-            for asset in additions:
-                cna_client.create(asset=asset, dry_run=dry_run)
-
-            deletions = current_state - desired_state
-            for asset in deletions:
-                cna_client.delete(asset=asset, dry_run=dry_run)
-
-            updates = current_state.required_updates_to_reach(desired_state)
-            for assets in updates:
-                cna_client.update(asset=assets, dry_run=dry_run)
-
-
-def build_cna_clients(
-    secret_reader: SecretReaderBase,
-    cna_provisioners: list[CNAExperimentalProvisionerV1],
-) -> dict[str, CNAClient]:
-    clients: dict[str, CNAClient] = {}
-    for provisioner in cna_provisioners:
-        access_token_client_secret = (
-            provisioner.ocm.access_token_client_secret
-            or provisioner.ocm.environment.access_token_client_secret
-        )
-        secret_data = secret_reader.read_all_secret(access_token_client_secret)
-        ocm_client = OCMBaseClient(
-            url=provisioner.ocm.environment.url,
-            access_token_client_secret=secret_data["client_secret"],
-            access_token_url=provisioner.ocm.access_token_url
-            or provisioner.ocm.environment.access_token_url,
-            access_token_client_id=provisioner.ocm.access_token_client_id
-            or provisioner.ocm.environment.access_token_client_id,
-        )
-        clients[provisioner.name] = CNAClient(
-            ocm_client=ocm_client,
-        )
-    return clients
-
-
-def run(
-    dry_run: bool,
-    # TODO: Threadpool not used yet - will be used once we understand scopes in more detail
-    thread_pool_size: int,
-) -> None:
-    settings = get_app_interface_vault_settings()
-    secret_reader = create_secret_reader(use_vault=settings.vault)
-
-    query_func = gql.get_api().query
-    cna_provisioners = cna_provisioners_query(query_func).cna_provisioners or []
-    namespaces = namespaces_query(query_func).namespaces or []
-
-    cna_clients = build_cna_clients(
-        secret_reader=secret_reader, cna_provisioners=cna_provisioners
-    )
-
-    integration = CNAIntegration(cna_clients=cna_clients, namespaces=namespaces)
-    integration.assemble_current_states()
-    integration.assemble_desired_states()
-    integration.provision(dry_run=dry_run)

qontract_reconcile-0.10.2.dev221/reconcile/cna/state.py

@@ -1,128 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import (
-    Iterable,
-    Mapping,
-)
-from typing import Any
-
-from reconcile.cna.assets.asset import (
-    Asset,
-    AssetStatus,
-    AssetType,
-)
-from reconcile.cna.assets.asset_factory import asset_factory_from_raw_data
-
-
-class CNAStateError(Exception):
-    pass
-
-
-class State:
-    """
-    State object is a collection of assets.
-    It can be used to describe actual or desired state.
-    Main objective is to calculate required additions,
-    deletions and updates to reach another state.
-    """
-
-    def __init__(self, assets: dict[AssetType, dict[str, Asset]] | None = None):
-        self._assets: dict[AssetType, dict[str, Asset]] = {}
-        for kind in AssetType:
-            self._assets[kind] = {}
-        if assets:
-            self._assets = assets
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, State):
-            return False
-        if not set(self._assets.keys()) == set(other._assets.keys()):
-            return False
-        for kind in list(self._assets.keys()):
-            if not set(self._assets[kind]) == set(other._assets[kind]):
-                return False
-            for name, asset in self._assets[kind].items():
-                if asset != other._assets[kind][name]:
-                    return False
-        return True
-
-    def __repr__(self) -> str:
-        # pytest should show nice diff
-        return str(self._assets)
-
-    def _validate_addition(self, asset: Asset) -> None:
-        if asset.kind not in self._assets:
-            raise CNAStateError(f"State doesn't know asset_kind {asset.kind}")
-        if asset.name in self._assets[asset.kind]:
-            raise CNAStateError(
-                f"Duplicate asset name found in state: kind={asset.kind}, name={asset.name}"
-            )
-
-    def add_asset(self, asset: Asset) -> None:
-        self._validate_addition(asset=asset)
-        self._assets[asset.kind][asset.name] = asset
-
-    def add_raw_data(self, data: Iterable[Mapping[str, Any]]) -> None:
-        for cna in data:
-            asset = asset_factory_from_raw_data(cna)
-            self._validate_addition(asset=asset)
-            self._assets[asset.kind][asset.name] = asset
-
-    def required_updates_to_reach(self, other: State) -> State:
-        """
-        This operation is NOT commutative, i.e.,:
-        a.required_updates_to_reach(b) != b.required_updates_to_reach(a)
-
-        This is supposed to be called on actual state (self).
-        I.e., actual.required_updates_to_reach(desired)
-        """
-        ans = State()
-        for kind in AssetType:
-            for asset_name, other_asset in other._assets[kind].items():
-                if asset_name not in self._assets[kind]:
-                    continue
-                asset = self._assets[kind][asset_name]
-                if asset.status in {AssetStatus.TERMINATED, AssetStatus.PENDING}:
-                    continue
-                if asset == other_asset:
-                    # There is no diff - no need to update
-                    continue
-                ans.add_asset(asset=asset.update_from(other_asset))
-        return ans
-
-    def __sub__(self, other: State) -> State:
-        """
-        This is used to determine creations and deletions
-        of assets. We only check the existance of the name
-        in each state. TERMINATED and PENDING assets are
-        omitted.
-
-        additions = self - other
-        deletions = other - self
-        """
-        ans = State()
-        for kind in AssetType:
-            for asset_name, asset in self._assets[kind].items():
-                if asset.status in {AssetStatus.TERMINATED, AssetStatus.PENDING}:
-                    continue
-                if other_asset := other._assets[kind].get(asset_name):
-                    if other_asset.status == AssetStatus.TERMINATED:
-                        raise CNAStateError(
-                            f"Trying to create/update terminated asset {asset}. Currently not possible."
-                        )
-                    continue
-                ans.add_asset(asset)
-        return ans
-
-    def __iter__(self) -> State:
-        self._i = 0
-        self._assets_list: list[Asset] = []
-        for kind in AssetType:
-            self._assets_list += list(self._assets[kind].values())
-        return self
-
-    def __next__(self) -> Asset:
-        if self._i < len(self._assets_list):
-            self._i += 1
-            return self._assets_list[self._i - 1]
-        raise StopIteration

qontract_reconcile-0.10.2.dev221/reconcile/gql_definitions/cna/queries/cna_provisioners.py

@@ -1,106 +0,0 @@
-"""
-Generated by qenerate plugin=pydantic_v1. DO NOT MODIFY MANUALLY!
-"""
-from collections.abc import Callable  # noqa: F401 # pylint: disable=W0611
-from datetime import datetime  # noqa: F401 # pylint: disable=W0611
-from enum import Enum  # noqa: F401 # pylint: disable=W0611
-from typing import (  # noqa: F401 # pylint: disable=W0611
-    Any,
-    Optional,
-    Union,
-)
-
-from pydantic import (  # noqa: F401 # pylint: disable=W0611
-    BaseModel,
-    Extra,
-    Field,
-    Json,
-)
-
-from reconcile.gql_definitions.fragments.ocm_environment import OCMEnvironment
-from reconcile.gql_definitions.fragments.vault_secret import VaultSecret
-
-
-DEFINITION = """
-fragment OCMEnvironment on OpenShiftClusterManagerEnvironment_v1 {
-    name
-    description
-    labels
-    url
-    accessTokenClientId
-    accessTokenUrl
-    accessTokenClientSecret {
-        ... VaultSecret
-    }
-}
-
-fragment VaultSecret on VaultSecret_v1 {
-    path
-    field
-    version
-    format
-}
-
-query CNAProvisioners {
-  cna_provisioners: cna_experimental_provisioners_v1 {
-    name
-    description
-    ocm {
-      name
-      orgId
-      accessTokenUrl
-      accessTokenClientId
-      accessTokenClientSecret {
-        ... VaultSecret
-      }
-      environment {
-        ... OCMEnvironment
-      }
-    }
-  }
-}
-"""
-
-
-class ConfiguredBaseModel(BaseModel):
-    class Config:
-        smart_union=True
-        extra=Extra.forbid
-
-
-class OpenShiftClusterManagerV1(ConfiguredBaseModel):
-    name: str = Field(..., alias="name")
-    org_id: str = Field(..., alias="orgId")
-    access_token_url: Optional[str] = Field(..., alias="accessTokenUrl")
-    access_token_client_id: Optional[str] = Field(..., alias="accessTokenClientId")
-    access_token_client_secret: Optional[VaultSecret] = Field(..., alias="accessTokenClientSecret")
-    environment: OCMEnvironment = Field(..., alias="environment")
-
-
-class CNAExperimentalProvisionerV1(ConfiguredBaseModel):
-    name: str = Field(..., alias="name")
-    description: Optional[str] = Field(..., alias="description")
-    ocm: OpenShiftClusterManagerV1 = Field(..., alias="ocm")
-
-
-class CNAProvisionersQueryData(ConfiguredBaseModel):
-    cna_provisioners: Optional[list[CNAExperimentalProvisionerV1]] = Field(..., alias="cna_provisioners")
-
-
-def query(query_func: Callable, **kwargs: Any) -> CNAProvisionersQueryData:
-    """
-    This is a convenience function which queries and parses the data into
-    concrete types. It should be compatible with most GQL clients.
-    You do not have to use it to consume the generated data classes.
-    Alternatively, you can also mime and alternate the behavior
-    of this function in the caller.
-
-    Parameters:
-        query_func (Callable): Function which queries your GQL Server
-        kwargs: optional arguments that will be passed to the query function
-
-    Returns:
-        CNAProvisionersQueryData: queried data parsed into generated classes
-    """
-    raw_data: dict[Any, Any] = query_func(DEFINITION, **kwargs)
-    return CNAProvisionersQueryData(**raw_data)