Source code for smarter.apps.infrastructure.providers.memory

"""
A cloud provider in memory, for tests and local development without a cloud account.

Its DNS zones, records and certificates are kept in memory, and behave like a cloud's, so that
tests exercise the service layer, and its signals, without reaching real infrastructure.

.. code-block:: python

    from smarter.apps.infrastructure.providers import configure_provider
    from smarter.apps.infrastructure.providers.memory import InMemoryProvider

    provider = InMemoryProvider()
    configure_provider(lambda: provider)
    provider.dns.add_zone("example.com")
    provider.certificates.issue_all = True
    provider.storage.objects  # the private objects that were saved, by key
"""

import copy
from dataclasses import dataclass
from typing import Optional
from urllib.parse import quote

from smarter.apps.infrastructure.cluster_health import ClusterHealth
from smarter.apps.infrastructure.const import CertificateStatus, CloudProviders
from smarter.apps.infrastructure.services.base import DiscoveredResource
from smarter.apps.infrastructure.services.certificates import (
    Certificate,
    CertificateService,
)
from smarter.apps.infrastructure.services.dns import (
    DNSRecord,
    DNSService,
    DNSZone,
    normalize_name,
)
from smarter.apps.infrastructure.services.storage import StorageService
from smarter.lib.typing import SmarterDictType

from .base import CloudProvider

ACCOUNT_ID = "000000000000"


[docs] class InMemoryDNSService(DNSService): """DNS zones and records in memory.""" record_wait_seconds = 0
[docs] def __init__(self, provider: "InMemoryProvider", **kwargs): super().__init__(provider_name=provider.provider_name, **kwargs) self.provider = provider self.zones: dict[str, DNSZone] = {} self.records: dict[str, list[DNSRecord]] = {}
@property def ready(self) -> bool: """Whether the in-memory provider is ready.""" return self.provider.ready
[docs] def add_zone(self, domain: str, a_record: Optional[list[str]] = None) -> DNSZone: """ Add a zone, e.g. the environment's API domain, optionally with an A record. :param domain: The zone's domain, e.g. ``api.example.com``. :param a_record: The A record's values, IP addresses, or None for no A record. :returns: The new zone. """ zone = self._create_zone(domain) if a_record: self._upsert_record(zone.id, DNSRecord(name=domain, type="A", ttl=600, values=a_record), create=True) return zone
def _find_zone(self, domain: str) -> Optional[DNSZone]: domain = normalize_name(domain) return next((copy.deepcopy(z) for z in self.zones.values() if z.name == domain), None) def _find_zone_by_id(self, zone_id: str) -> Optional[DNSZone]: zone = self.zones.get(zone_id) return copy.deepcopy(zone) if zone else None def _create_zone(self, domain: str) -> DNSZone: zone_id = f"Z{len(self.zones) + 1:012d}" name_servers = [f"ns-{i}.memory-dns.example" for i in range(1, 5)] zone = DNSZone(id=zone_id, name=domain, name_servers=name_servers) self.zones[zone_id] = zone self.records[zone_id] = [DNSRecord(name=domain, type="NS", ttl=172800, values=name_servers)] return copy.deepcopy(zone) def _delete_zone(self, zone: DNSZone) -> None: self.zones.pop(zone.id, None) self.records.pop(zone.id, None) def _list_records(self, zone_id: str) -> list[DNSRecord]: return copy.deepcopy(self.records.get(zone_id, [])) def _upsert_record(self, zone_id: str, record: DNSRecord, create: bool) -> None: records = self.records.setdefault(zone_id, []) records[:] = [r for r in records if (r.name, r.type) != (record.name, record.type)] records.append(copy.deepcopy(record)) def _delete_record(self, zone_id: str, record: DNSRecord) -> None: records = self.records.get(zone_id, []) records[:] = [r for r in records if (r.name, r.type) != (record.name, record.type)]
[docs] class InMemoryCertificateService(CertificateService): """TLS certificates in memory, issued once their validation records exist, or at once with :attr:`issue_all`.""" validation_wait_seconds = 0 issue_wait_seconds = 0
[docs] def __init__(self, provider: "InMemoryProvider", dns: DNSService, **kwargs): super().__init__(provider.provider_name, dns, **kwargs) self.provider = provider self.certificates: dict[str, Certificate] = {} self.issue_all = False """Issue every certificate, whether or not its validation records exist."""
@property def ready(self) -> bool: """Whether the in-memory provider is ready.""" return self.provider.ready def _find_certificate_id(self, domain_name: str) -> Optional[str]: domain_name = normalize_name(domain_name) return next((c.id for c in self.certificates.values() if c.domain_name == domain_name), None) def _request_certificate(self, domain_name: str) -> str: domain_name = normalize_name(domain_name) certificate_id = f"memory:certificate/{len(self.certificates) + 1}" self.certificates[certificate_id] = Certificate( id=certificate_id, domain_name=domain_name, status=CertificateStatus.PENDING_VALIDATION, validation_records=[ DNSRecord(name=f"_validation.{domain_name}", type="CNAME", values=[f"_{len(self.certificates)}.memory"]) ], ) return certificate_id def _validated(self, certificate: Certificate) -> bool: zone = self.dns.get_zone(certificate.domain_name) if zone is None: return False return all( self.dns.get_record(zone.id, record.name, record.type) is not None for record in certificate.validation_records ) def _describe_certificate(self, certificate_id: str) -> Optional[Certificate]: certificate = self.certificates.get(certificate_id) if certificate is None: return None if certificate.status == CertificateStatus.PENDING_VALIDATION and ( self.issue_all or self._validated(certificate) ): certificate.status = CertificateStatus.ISSUED return copy.deepcopy(certificate) def _delete_certificate(self, certificate_id: str) -> None: self.certificates.pop(certificate_id, None)
[docs] @dataclass class StoredObject: """An object that :class:`InMemoryStorageService` saved.""" content: bytes content_type: str
[docs] class InMemoryStorageService(StorageService): """ Private objects in memory, in :attr:`objects`. Its presigned urls are fake: they name the object and when the url expires, but download nothing. """
[docs] def __init__(self, provider: "InMemoryProvider", **kwargs): super().__init__(provider_name=provider.provider_name, **kwargs) self.provider = provider self.objects: dict[str, StoredObject] = {} """The objects, by key.""" self.fail: Optional[str] = None """Set to make every operation fail with this error."""
@property def ready(self) -> bool: """Whether the in-memory provider is ready.""" return self.provider.ready @property def bucket(self) -> str: """The fixed bucket ``memory-exports``.""" return "memory-exports" def _check(self) -> None: if self.fail: raise RuntimeError(self.fail) def _put_object(self, key: str, content: bytes, content_type: str) -> None: self._check() self.objects[key] = StoredObject(content=content, content_type=content_type) def _presigned_url(self, key: str, expires_in: int, filename: Optional[str]) -> str: self._check() url = f"https://storage.memory.example/{self.bucket}/{quote(key)}?expires_in={expires_in}" if filename: url += f"&filename={quote(filename)}" return url def _delete_object(self, key: str) -> None: self._check() self.objects.pop(key, None)
[docs] class InMemoryProvider(CloudProvider): """ A cloud provider in memory. :param ready: Whether the provider is authenticated. """ name = CloudProviders.MEMORY
[docs] def __init__(self, ready: bool = True, **kwargs): super().__init__(allow_in_tests=True, **kwargs) self._ready = ready self._dns = InMemoryDNSService(self) self._certificates = InMemoryCertificateService(self, self._dns) self._storage = InMemoryStorageService(self) self.kubeconfig_updates = 0 self.cluster_info: SmarterDictType = { "health": {"issues": []}, "platformVersion": "memory", "status": "ACTIVE", "version": "1.33", } self.cluster_health: Optional[ClusterHealth] = None """The cluster's health, or None for the one that :attr:`cluster_info` describes.""" self.cluster_resources: dict[str, list[DiscoveredResource]] = {} """The cloud resources of the cluster, by resource type, for the inventory."""
@property def ready(self) -> bool: """ Whether the provider is ready, as set with the setter. Records the authentication state, which sends a signal when it changes. """ return self.authentication_state(self.identity, error="the in-memory provider is not ready") @ready.setter def ready(self, value: bool) -> None: """ Set whether the provider is ready, e.g. to test a provider that is not authenticated. :param value: Whether it is ready. """ self._ready = value @property def identity(self) -> Optional[SmarterDictType]: """A fake account identity, or None if the provider is not ready.""" return {"Account": ACCOUNT_ID, "Arn": f"memory::{ACCOUNT_ID}:user/smarter"} if self._ready else None @property def account_id(self) -> Optional[str]: """The fake account id, or None if the provider is not ready.""" return ACCOUNT_ID if self._ready else None @property def sdk_version(self) -> str: """The fixed version ``memory``.""" return "memory" @property def dns(self) -> InMemoryDNSService: """The in-memory DNS service.""" return self._dns @property def certificates(self) -> InMemoryCertificateService: """The in-memory certificate service.""" return self._certificates @property def storage(self) -> InMemoryStorageService: """The in-memory private object storage.""" return self._storage
[docs] def update_kubeconfig(self) -> bool: """ Count the call in :attr:`kubeconfig_updates`, rather than write a kubeconfig. :returns: Whether the provider is ready. """ self.kubeconfig_updates += 1 return self._ready
[docs] def get_kubernetes_cluster_info(self) -> SmarterDictType: """ Return a copy of :attr:`cluster_info`. :returns: The cluster's description. :raises InfrastructureNotReadyError: If the provider is not ready. """ self.require_ready() return dict(self.cluster_info)
[docs] def get_kubernetes_cluster_health(self) -> ClusterHealth: """ Return the cluster's health that a test set in :attr:`cluster_health`. Without one, it is built from :attr:`cluster_info`, as the base class builds it. :returns: A copy of the health, so that a caller cannot change the test's. :raises InfrastructureNotReadyError: If the provider is not ready. """ if self.cluster_health is None: return super().get_kubernetes_cluster_health() self.require_ready() return self.cluster_health.model_copy(deep=True)
[docs] def get_kubernetes_cluster_resources(self) -> dict[str, list[DiscoveredResource]]: """ Return a copy of :attr:`cluster_resources`, which tests set. :returns: The cluster's cloud resources, by resource type, or an empty dict if the provider is not ready. """ if not self.ready: return {} return copy.deepcopy(self.cluster_resources)
__all__ = [ "InMemoryCertificateService", "InMemoryDNSService", "InMemoryProvider", "InMemoryStorageService", "StoredObject", ]