ensure a list of BASH commands, e.g., `zrok enable` succeed for a list of zrok versions selected by criteria like min/max version and age.

zrok-test-cli-versions.py

import datetime
import logging
import os
import re
import time

import docker
import requests
from packaging import version

# Create a logger for your script
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)

# Create a console handler with a higher log level
handler = logging.StreamHandler()
handler.setLevel(logging.DEBUG)

# Create a formatter and add it to the handler
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)

# Add the handler to the logger
logger.addHandler(handler)


# find up to max_count semver tags no more than max_days old
def get_docker_tags_sorted_by_date(repo_name: str, max_days: int, max_count: int, min_version: str, max_version: str):
    url = f"https://hub.docker.com/v2/repositories/{repo_name}/tags"
    response = requests.get(url)
    tags = response.json()['results']
    logger.debug(f"found tags: {len(tags)}")

    semver_regex = (
        r"^"
        r"(0|[1-9]\d*)\."
        r"(0|[1-9]\d*)\."
        r"(0|[1-9]\d*)"
        r"(-("
        r"0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*"
        r")(\.("
        r"0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*"
        r"))*)?(\+[0-9a-zA-Z-]+(\.[0-9a-zA-Z-]+)*)?$"
    )

    if max_days is not None:
        cutoff_date = datetime.datetime.now() - datetime.timedelta(days=max_days)
        logger.debug(f"ignoring release tags updated before {cutoff_date}")
        tags = [
            tag for tag in tags
            if datetime.datetime.strptime(tag['last_updated'], "%Y-%m-%dT%H:%M:%S.%fZ") > cutoff_date
            and (re.match(semver_regex, tag['name']) or tag['name'] == 'latest')
        ]

    if min_version is not None:
        logger.debug(f"ignoring release tags before {min_version}")
        tags = [
            tag for tag in tags
            if tag['name'] == 'latest'
            or version.parse(tag['name']) >= version.parse(min_version)
        ]

    if max_version is not None:
        logger.debug(f"ignoring release tags after {max_version}")
        tags = [
            tag for tag in tags
            if tag['name'] == 'latest'
            or version.parse(tag['name']) < version.parse(max_version)
        ]

    sorted_tags = sorted(tags, key=lambda x: x['last_updated'], reverse=True)

    if max_count is not None:
        if len(sorted_tags) > max_count:
            logger.debug(f"ignoring {max_count - len(sorted_tags)} excess tags")
        sorted_tags = sorted_tags[:max_count]

    logger.debug(f"returning {len(sorted_tags)} tags")
    return sorted_tags


def run_docker_container(repo_name: str, tag: str):
    client = docker.from_env()
    image_name = f"{repo_name}:{tag}"
    command = [
        '-c',
        f'''
        set -euo pipefail;
        zrok version|grep -E '^v';
        zrok enable "{os.getenv('ZROK_ENABLE_TOKEN')}" --headless --description "enabled {tag}";
        sleep 3;
        zrok disable;
        ''',
    ]
    logger.debug(f"running {image_name} with command {command}")
    return client.containers.run(
        image_name, detach=True, entrypoint='/bin/bash',
        environment={
            "ZROK_API_ENDPOINT": os.getenv('ZROK_API_ENDPOINT'),
            "HOME": "/tmp",
        },
        command=command,
    )


if __name__ == "__main__":
    repo_name = 'openziti/zrok'
    max_days = 180
    max_count = 3
    min_version = '0.4.0'
    max_version = '0.5.0'
    sorted_tags = get_docker_tags_sorted_by_date(repo_name, max_days, max_count, min_version, max_version)

    for tag in sorted_tags:
        tag['container'] = run_docker_container(repo_name, tag['name'])
        time.sleep(3)
    for tag in sorted_tags:
        for line in tag['container'].logs(stream=True):
            print(line.strip())
        tag['container'].remove(force=True)