Files
ess-helm/tests/integration/lib/helpers.py
T

203 lines
7.2 KiB
Python

# Copyright 2024-2025 New Vector Ltd
# Copyright 2025 Element Creations Ltd
#
# SPDX-License-Identifier: AGPL-3.0-only
import asyncio
import os
import time
import pyhelm3
from lightkube import AsyncClient
from lightkube.models.core_v1 import (
Capabilities,
Container,
LocalObjectReference,
PodSpec,
SeccompProfile,
SecurityContext,
)
from lightkube.models.meta_v1 import ObjectMeta
from lightkube.resources.apps_v1 import Deployment
from lightkube.resources.core_v1 import ConfigMap, Endpoints, Namespace, Pod, Secret
from ..artifacts import CertKey
from .utils import merge
def namespace(name: str) -> Namespace:
return Namespace(metadata=ObjectMeta(name=name))
def kubernetes_docker_secret(name: str, namespace: str, docker_config_json: str) -> Secret:
secret = Secret(
type="kubernetes.io/dockerconfigjson",
metadata=ObjectMeta(name=name, namespace=namespace, labels={"app.kubernetes.io/managed-by": "pytest"}),
stringData={".dockerconfigjson": docker_config_json},
)
return secret
def kubernetes_tls_secret(name: str, namespace: str, certificate: CertKey) -> Secret:
secret = Secret(
type="kubernetes.io/tls",
metadata=ObjectMeta(name=name, namespace=namespace, labels={"app.kubernetes.io/managed-by": "pytest"}),
stringData={
"tls.crt": certificate.cert_bundle_as_pem(),
"tls.key": certificate.key_as_pem(),
"ca.crt": certificate.get_root_ca().cert_as_pem(),
},
)
return secret
async def wait_for_endpoint_ready(name, namespace, cluster, kube_client):
await asyncio.to_thread(
cluster.wait,
name=f"endpoints/{name}",
namespace=namespace,
waitfor="jsonpath='{.subsets[].addresses}'",
)
# We wait maximum 30 seconds for the endpoints to be ready
start_time = time.time()
while time.time() - start_time < 30:
endpoint = await kube_client.get(Endpoints, name=name, namespace=namespace)
for subset in endpoint.subsets:
if not subset or subset.notReadyAddresses or not subset.addresses or not subset.ports:
await asyncio.sleep(0.1)
break
else:
break
return endpoint
async def deploy_with_values_patch(
generated_data, helm_client: pyhelm3.Client, values_patch: dict, timeout="600s"
) -> tuple[pyhelm3.ReleaseRevision, pyhelm3.Error | None]:
# Get the current deployed values to patch them
revision = await helm_client.get_current_revision(
generated_data.release_name, namespace=generated_data.ess_namespace
)
values = await revision.values()
values = merge(values, values_patch)
chart = await helm_client.get_chart("charts/matrix-stack")
# Install or upgrade a release
error = None
try:
revision = await helm_client.install_or_upgrade_release(
generated_data.release_name,
chart,
values,
namespace=generated_data.ess_namespace,
timeout=timeout,
atomic=False,
wait=True,
)
except pyhelm3.errors.Error as e:
error = e
revision = await helm_client.get_current_revision(
generated_data.release_name, namespace=generated_data.ess_namespace
)
return revision, error
async def get_deployment_marker(kube_client, generated_data, marker: str):
# The marker should now show delegated_auth
configmap = await kube_client.get(
ConfigMap,
namespace=generated_data.ess_namespace,
name=f"{generated_data.release_name}-markers",
)
return configmap.data.get(marker)
async def run_pod_with_args(
kube_client: AsyncClient, generated_data, image_name, pod_name, args, restart_policy="Never"
):
pod_pull_secrets = []
if os.environ.get("CI") and ("DOCKERHUB_USERNAME" in os.environ) and ("DOCKERHUB_TOKEN" in os.environ):
pod_pull_secrets = [
LocalObjectReference(name=f"{generated_data.release_name}-dockerhub"),
]
pod = Pod(
metadata=ObjectMeta(name=pod_name + "-" + str(int(time.time() * 1000)), namespace=generated_data.ess_namespace),
spec=PodSpec(
restartPolicy=restart_policy,
imagePullSecrets=pod_pull_secrets,
containers=[
Container(
name="cmd",
image=image_name,
args=args,
securityContext=SecurityContext(
seccompProfile=SeccompProfile(type="RuntimeDefault"),
capabilities=Capabilities(drop=["ALL"]),
readOnlyRootFilesystem=True,
allowPrivilegeEscalation=False,
runAsNonRoot=True,
runAsUser=3000,
runAsGroup=3000,
),
)
],
),
)
assert pod.metadata
assert pod.metadata.name
assert pod.metadata.namespace
await kube_client.create(pod)
start_time = time.time()
now = time.time()
completed = False
while start_time + 60 > now and not completed:
found_pod = await kube_client.get(Pod, name=pod.metadata.name, namespace=pod.metadata.namespace)
if (
found_pod.status
and found_pod.status.containerStatuses
and found_pod.status.containerStatuses[0].state
and found_pod.status.containerStatuses[0].state.terminated
and found_pod.status.containerStatuses[0].state.terminated.reason == "Completed"
):
completed = True
else:
now = time.time()
await asyncio.sleep(1)
else:
if start_time + 60 <= now:
raise RuntimeError(
f"Pod {pod.metadata.name} did not start in time "
f"(failed after {now - start_time} seconds), "
f"pod status: {found_pod.status}"
)
log_lines = ""
async for log_line in kube_client.log(pod.metadata.name, namespace=pod.metadata.namespace, container="cmd"):
log_lines += log_line
await kube_client.delete(Pod, name=pod.metadata.name, namespace=generated_data.ess_namespace)
return log_lines
async def wait_for_all_deployments_rolled_out(kube_client: AsyncClient, namespace: str):
timeout = 30
start_time = time.time()
now = time.time()
while start_time + timeout > now:
now = time.time()
await asyncio.sleep(0.5)
async for deployment in kube_client.list(Deployment, namespace=namespace):
# replicas: Total number of non-terminating pods targeted by this deployment
# updatedReplicas: Total number of non-terminating pods targeted by this deployment that have
# the desired template spec.
if not deployment.status or not deployment.status.updatedReplicas or not deployment.status.replicas:
break
if deployment.status.updatedReplicas != deployment.status.replicas:
break
if not deployment.spec or not deployment.spec.replicas:
break
if deployment.spec.replicas != deployment.status.replicas:
break
else:
return