Merge ~cjdc/ubuntu-docker-images/+git/templates:add-skopeo-authfile into ~ubuntu-docker-images/ubuntu-docker-images/+git/templates:main

[Cristovao Cordeiro]

fix: Skopeo needs an --authfile for private repos

[Samir Akarioh (samiraka)]

You need to change some signatures of some function

review: Approve

[Cristovao Cordeiro (cjdc)]

> You need to change some signatures of some function

good catch. done, ty

[Samir Akarioh (samiraka)]

Good for me, you can merge it

diff --git a/README.md b/README.md
index 29d4e38..6d86182 100644
--- a/README.md
+++ b/README.md
@@ -15,12 +15,12 @@ The DevContainer will provide you with a working environment out of the box. **Y
 ```bash
 git clone https://github.com/misterw97/RenderDown
 sudo apt update && sudo apt install -y python3-mako python3-yaml
-pip install boto3 # if you want to run the generate_ubuntu_yaml file
+pip install boto3 requests pyyaml && apt install -y distro-info  # if you want to run the generate_ubuntu_yaml script
 ```
 
 #### Generate_ubuntu_yaml
 
-This script allows to generate the ubuntu.yaml file in order to use it by the RenderDown script. It uses the template ubuntu.yaml located in the template folder.
+This script allows us to generate the ubuntu.yaml file in order to use it by the RenderDown script. It uses the template ubuntu.yaml located in the template folder.
 
 Here are the available arguments and examples of commands: 
 
diff --git a/generate_ubuntu_yaml.py b/generate_ubuntu_yaml.py
index 6c70e7c..dacd6e5 100755
--- a/generate_ubuntu_yaml.py
+++ b/generate_ubuntu_yaml.py
@@ -1,525 +1,518 @@
 #!/usr/bin/env python3
 
 import argparse
+import base64
 import datetime
 import json
 import logging
 import os
 import subprocess
+import sys
 from typing import Dict, List
 
 import boto3
 import requests
-import sys
+import tempfile
 import yaml
 
 logging.basicConfig(stream=sys.stdout, level=logging.INFO)
-NOW = datetime.datetime.now()
 SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
 
 
-def cli_args() -> argparse.ArgumentParser:
-    """Argument parser"""
-    parser = argparse.ArgumentParser(
-        description="Generate documentation about Ubuntu for ECR and DockerHub"
-    )
-
-    parser.add_argument(
-        "--provider",
-        default="docker",
-        dest="provider",
-        help="aws or docker",
-        required=True,
-    )
-    parser.add_argument(
-        "--username",
-        default="admin",
-        dest="username",
-        help="either the Docker Hub username, or the AWS access key ID",
-        required=True,
-    )
-    parser.add_argument(
-        "--password",
-        default="admin",
-        dest="password",
-        help="either the Docker Hub password/token, or the AWS secret access key",
-        required=True,
-    )
-    parser.add_argument(
-        "--token-docker",
-        dest="dockertoken",
-        default=None,
-        help="JWT token for Docker Hub authentication. \
-            Only useful for the 'docker' provider.",
-    )
-    parser.add_argument(
-        "--repository-basename",
-        dest="repository",
-        default=None,
-        help="repository basename of the ubuntu images. \
-            Used to infer existing information.",
-    )
-    parser.add_argument(
-        "--data-dir",
-        default="data",
-        dest="data_dir",
-        help="""The path of the folder
-                where the data file will be
-                saved ( if not exist, the script
-                will create the folder)""",
-    )
-    parser.add_argument(
-        "--unpublished-suite",
-        dest="unpublished_suite",
-        help="""an Ubuntu Suite (e.g. jammy).
-                if given we will take the
-                tags pass on command lines (required)
-                and the arches for this section
-                of the yaml file.
-            """,
-    )
-    parser.add_argument(
-        "--unpublished-tags",
-        dest="unpublished_tags",
-        help="""list of tags
-        (e.g. 'kinetic 22.10 22.10_edge kinetic)""",
-    )
-    parser.add_argument(
-        "--unpublished-archs",
-        dest="unpublished_archs",
-        help="list of archs (e.g amd64 arm)",
-    )
-
-    return parser
-
-
-def validate_args(
-    parser: argparse.ArgumentParser,
-) -> argparse.ArgumentParser.parse_args:
-    """Parse and validate the CLI arguments"""
-    args = parser.parse_args()
-    if any(
-        [
-            args.unpublished_suite is None,
-            args.unpublished_tags is None,
-            args.unpublished_archs is None,
-        ]
-    ) and not all(
-        [
-            args.unpublished_suite is None,
-            args.unpublished_tags is None,
-            args.unpublished_archs is None,
-        ]
-    ):
-        parser.error(
-            """--unpublished-suite need
-                        --unpublished-archs and --unpublished_tags"""
-        )
-
-    return args
+class GenerateUbuntuYaml:
+    def __init__(self):
+        self.now = datetime.datetime.now()
+        self.validate_args()
+        self.add_yaml_representer()
+        self.build_image_endpoint()
+        self._skopeo_auth_token = None
 
+    @staticmethod
+    def cli_args() -> argparse.ArgumentParser:
+        """Argument parser"""
+        parser = argparse.ArgumentParser(
+            description="Generate documentation about Ubuntu for ECR and DockerHub"
+        )
 
-def build_image_endpoint(provider: str, repo_base: str = None) -> (str, str):
-    """Define the image's registry URL"""
-    if provider == "aws":
-        registry_url = "docker://public.ecr.aws/"
-        staging_repo = "rocksdev"
-    else:
-        registry_url = "docker://docker.io/"
-        staging_repo = "rocksdev4staging"
+        parser.add_argument(
+            "--provider",
+            default="docker",
+            dest="provider",
+            help="aws or docker",
+            required=True,
+        )
+        parser.add_argument(
+            "--username",
+            default="admin",
+            dest="username",
+            help="either the Docker Hub username, or the AWS access key ID",
+            required=True,
+        )
+        parser.add_argument(
+            "--password",
+            default="admin",
+            dest="password",
+            help="either the Docker Hub password/token, or the AWS secret access key",
+            required=True,
+        )
+        parser.add_argument(
+            "--jwt-token-docker",
+            dest="jwt_token_docker",
+            default=None,
+            help="JWT token for Docker Hub authentication. \
+                Only useful for the 'docker' provider.",
+        )
+        parser.add_argument(
+            "--repository-basename",
+            dest="repository",
+            default=None,
+            help="repository basename of the ubuntu images. \
+                Used to infer existing information.",
+        )
+        parser.add_argument(
+            "--data-dir",
+            default="data",
+            dest="data_dir",
+            help="""The path of the folder
+                    where the data file will be
+                    saved ( if not exist, the script
+                    will create the folder)""",
+        )
+        parser.add_argument(
+            "--unpublished-suite",
+            dest="unpublished_suite",
+            help="""an Ubuntu Suite (e.g. jammy).
+                    if given we will take the
+                    tags pass on command lines (required)
+                    and the arches for this section
+                    of the yaml file.
+                """,
+        )
+        parser.add_argument(
+            "--unpublished-tags",
+            dest="unpublished_tags",
+            help="""list of tags
+            (e.g. 'kinetic 22.10 22.10_edge kinetic)""",
+        )
+        parser.add_argument(
+            "--unpublished-archs",
+            dest="unpublished_archs",
+            help="list of archs (e.g amd64 arm)",
+        )
 
-    if repo_base is None:
-        logging.warning("Using staging repository")
-        url = f"{registry_url}{staging_repo}/ubuntu"
-        namespace = staging_repo
-    else:
-        url = f"{registry_url}{repo_base}/ubuntu"
-        namespace = repo_base
+        return parser
+
+    def validate_args(self) -> None:
+        """Parse and validate the CLI arguments"""
+        parser = self.cli_args()
+        parser.parse_args(namespace=self)
+        if any(
+            [
+                self.unpublished_suite is None,
+                self.unpublished_tags is None,
+                self.unpublished_archs is None,
+            ]
+        ) and not all(
+            [
+                self.unpublished_suite is None,
+                self.unpublished_tags is None,
+                self.unpublished_archs is None,
+            ]
+        ):
+            parser.error(
+                """--unpublished-suite need
+                            --unpublished-archs and --unpublished_tags"""
+            )
 
-    logging.info(f"Using {url} to collect information")
+    def build_image_endpoint(self) -> None:
+        """Define the image's registry URL"""
+        if self.provider == "aws":
+            registry_url = "public.ecr.aws/"
+            staging_repo = "rocksdev"
+        else:
+            registry_url = "docker.io/"
+            staging_repo = "rocksdev4staging"
 
-    return url, namespace
+        if self.repository is None:
+            logging.warning("Using staging repository")
+            self.url = f"{registry_url}{staging_repo}/ubuntu"
+            self.namespace = staging_repo
+        else:
+            self.url = f"{registry_url}{self.repository}/ubuntu"
+            self.namespace = self.repository
+
+        logging.info(f"Using {self.url} to collect information")
+
+    @staticmethod
+    def add_yaml_representer() -> None:
+        def str_presenter(dumper, data):
+            """
+            Permit to format
+            multiline string into
+            yaml file
+            """
+
+            c = "tag:yaml.org,2002:str"
+            if len(data.splitlines()) > 1:  # check for multiline string
+                return dumper.represent_scalar(c, data, style="|")
+            return dumper.represent_scalar(c, data)
+
+        yaml.add_representer(str, str_presenter)
+        yaml.representer.SafeRepresenter.add_representer(str, str_presenter)
+
+    @staticmethod
+    def process_run(command: List[str], **kwargs) -> str:
+        """Run a command and handle its output."""
+        logging.info(f"Execute process: {command!r}, kwargs={kwargs!r}")
+        try:
+            out = subprocess.run(
+                command,
+                **kwargs,
+                capture_output=True,
+                check=True,
+                universal_newlines=True,
+            )
+        except subprocess.CalledProcessError as err:
+            msg = f"Failed to run command: {err!s}"
+            if err.stderr:
+                msg += f" ({err.stderr.strip()!s})"
+            raise Exception(msg) from err
+
+        return out.stdout.strip()
+
+    def run_skopeo_command(self, cmd: str, args: List[str]) -> Dict:
+        """Builds the Skopeo command and runs it"""
+        command = ["skopeo", cmd]
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            if self._skopeo_auth_token:
+                auth_config = {
+                    "auths": {self.url: {"auth": self._skopeo_auth_token}}
+                }
+                auth_file = os.path.join(tmp_dir, "auth.json")
+                with open(auth_file, "w") as f:
+                    os.fchmod(f.fileno(), 0o600)
+                    json.dump(auth_config, f)
+                command += ["--authfile", auth_file]
+            command += args
+
+            return json.loads(self.process_run(command))
+
+    def get_arches(self, release: str) -> List[str]:
+        """
+        Permit to get the arches associated to the release
+        """
+        logging.info(f"Getting the arches for {release}")
+        manifest = self.run_skopeo_command(
+            "inspect", [f"docker://{self.url}:{release}", "--raw"]
+        )["manifests"]
+        arches = []
+        for arch in manifest:
+            arches.append(arch["platform"]["architecture"])
+        return arches
+
+    def get_dockerhub_jwt_token(self) -> str:
+        """
+        Permit to get the token  associated to the docker account
+        """
+        logging.info("Getting the token form Docker")
 
+        url_token = "https://hub.docker.com/v2/users/login"
+        data = {"username": self.username, "password": self.password}
+        get_jwt_token = requests.post(url_token, json=data)
+        get_jwt_token.raise_for_status()
+        return get_jwt_token.json()["token"]
 
-def add_yaml_representer():
-    def str_presenter(dumper, data):
+    def get_tags_docker(self, release: str, token: str) -> List[str]:
         """
-        Permit to format
-        multiline string into
-        yaml file
+        Permit to get the tags associated to the release
         """
-
-        c = "tag:yaml.org,2002:str"
-        if len(data.splitlines()) > 1:  # check for multiline string
-            return dumper.represent_scalar(c, data, style="|")
-        return dumper.represent_scalar(c, data)
-
-    yaml.add_representer(str, str_presenter)
-    yaml.representer.SafeRepresenter.add_representer(str, str_presenter)
-
-
-def _process_run(command: List[str], **kwargs) -> str:
-    """Run a command and handle its output."""
-    logging.info(f"Execute process: {command!r}, kwargs={kwargs!r}")
-    try:
-        out = subprocess.run(
-            command,
-            **kwargs,
-            capture_output=True,
-            check=True,
-            universal_newlines=True,
+        logging.info(f"Getting the tags from Docker for {release}")
+        tags = []
+        result_json = self.run_skopeo_command(
+            "inspect", [f"docker://{self.url}:{release}", "--raw"]
         )
-    except subprocess.CalledProcessError as err:
-        msg = f"Failed to run command: {err!s}"
-        if err.stderr:
-            msg += f" ({err.stderr.strip()!s})"
-        raise Exception(msg) from err
-
-    return out.stdout.strip()
-
-
-def get_arches(release: str, image_url: str) -> List[str]:
-    """
-    Permit to get the arches associated to the release
-    """
-    logging.info(f"Getting the arches for {release}")
-    command = ["skopeo", "inspect", f"{image_url}:{release}", "--raw"]
-    manifest = json.loads(_process_run(command))["manifests"]
-    arches = []
-    for arch in manifest:
-        arches.append(arch["platform"]["architecture"])
-    return arches
-
-
-def get_dockerhub_token(username: str, password: str) -> str:
-    """
-    Permit to get the token  associated to the docker account
-    """
-    logging.info("Getting the token form Docker")
-
-    url_token = "https://hub.docker.com/v2/users/login"
-    data = {"username": username, "password": password}
-    get_token = requests.post(url_token, json=data)
-    get_token.raise_for_status()
-    return get_token.json()["token"]
-
-
-def get_tags_docker(
-    release: str, token: str, image_url: str, image_namespace: str
-) -> List[str]:
-    """
-    Permit to get the tags associated to the release
-    """
-    logging.info(f"Getting the tags from Docker for {release}")
-    tags = []
-    command = [
-        "skopeo",
-        "inspect",
-        f"{image_url}:{release}",
-        "--raw",
-    ]
-    result_json = _process_run(command)
-    digest = json.loads(result_json)["manifests"][0]["digest"]
-
-    url_dockerhub = "https://hub.docker.com/v2/repositories/"
-    url_dockerhub += f"{image_namespace}/ubuntu/tags/?page_size=999"
-    Headers = {"Authorization": f"JWT {token}"}
-    get_the_tags = requests.get(url_dockerhub, headers=Headers)
-    get_the_tags = get_the_tags.json()["results"]
-    for image in get_the_tags:
-        for info_image in image["images"]:
-            if info_image["digest"] == digest and image["name"] not in tags:
-                tags.append(image["name"])
-
-    return tags
-
-
-def get_tags_aws(release: str, client: boto3.Session, image_url: str) -> List[str]:
-    """
-    Permit to get the tags associated to the release
-    """
-    logging.info(f"Getting the tags from AWS for {release}")
-
-    tags = []
-    command = [
-        "skopeo",
-        "inspect",
-        f"{image_url}:{release}",
-    ]
-    result_json = _process_run(command)
-    digest = json.loads(result_json)["Digest"]
-    response = client.describe_image_tags(repositoryName="ubuntu")
-
-    for image in response["imageTagDetails"]:
-        if (
-            image["imageDetail"]["imageDigest"] == digest
-            and image["imageTag"] not in tags
-        ):
-            tags.append(image["imageTag"])
-    return tags
+        digest = result_json["manifests"][0]["digest"]
 
+        url_dockerhub = "https://hub.docker.com/v2/repositories/"
+        url_dockerhub += f"{self.namespace}/ubuntu/tags/?page_size=999"
+        Headers = {"Authorization": f"JWT {token}"}
+        get_the_tags = requests.get(url_dockerhub, headers=Headers)
+        get_the_tags = get_the_tags.json()["results"]
+        for image in get_the_tags:
+            for info_image in image["images"]:
+                if info_image["digest"] == digest and image["name"] not in tags:
+                    tags.append(image["name"])
 
-def get_fullname(release: str) -> str:
-    """
-    Permit to get the full name associated to the release
-    """
-    logging.info(f"Getting full name of {release} ")
+        return tags
 
-    command = ["ubuntu-distro-info", f"--series={release}", "-f"]
-    result_json = _process_run(command)
-    return result_json.replace("Ubuntu", "").strip()
+    def get_tags_aws(self, release: str, client: boto3.Session) -> List[str]:
+        """
+        Permit to get the tags associated to the release
+        """
+        logging.info(f"Getting the tags from AWS for {release}")
 
+        tags = []
+        result_json = self.run_skopeo_command(
+            "inspect", [f"docker://{self.url}:{release}"]
+        )
+        digest = result_json["Digest"]
+        response = client.describe_image_tags(repositoryName="ubuntu")
+
+        for image in response["imageTagDetails"]:
+            if (
+                image["imageDetail"]["imageDigest"] == digest
+                and image["imageTag"] not in tags
+            ):
+                tags.append(image["imageTag"])
+        return tags
+
+    def get_fullname(self, release: str) -> str:
+        """
+        Permit to get the full name associated to the release
+        """
+        logging.info(f"Getting full name of {release} ")
 
-def get_support(series: str, is_lts: bool) -> Dict[str, Dict[str, str]]:
-    """Calculates the end of support dates for a given Ubuntu series"""
-    logging.info(f"Getting support information for the {series}")
+        command = ["ubuntu-distro-info", f"--series={release}", "-f"]
+        result_json = self.process_run(command)
+        return result_json.replace("Ubuntu", "").strip()
 
-    base_cmd = ["ubuntu-distro-info", "--series", series]
-    eol_cmd = base_cmd + ["--day=eol"]
+    def get_support(self, series: str, is_lts: bool) -> Dict[str, Dict[str, str]]:
+        """Calculates the end of support dates for a given Ubuntu series"""
+        logging.info(f"Getting support information for the {series}")
 
-    eol = int(_process_run(eol_cmd))
-    eol_date = NOW + datetime.timedelta(days=eol)
+        base_cmd = ["ubuntu-distro-info", "--series", series]
+        eol_cmd = base_cmd + ["--day=eol"]
 
-    support = {"support": {"until": f"{eol_date.month:02d}/{eol_date.year}"}}
+        eol = int(self.process_run(eol_cmd))
+        eol_date = self.now + datetime.timedelta(days=eol)
 
-    if not is_lts:
-        return support
+        support = {"support": {"until": f"{eol_date.month:02d}/{eol_date.year}"}}
 
-    # The it is LTS, and lts_until=until
-    support["support"]["lts_until"] = support["support"]["until"]
+        if not is_lts:
+            return support
 
-    eol_esm_cmd = base_cmd + ["--day=eol-esm"]
+        # The it is LTS, and lts_until=until
+        support["support"]["lts_until"] = support["support"]["until"]
 
-    eol_esm = int(_process_run(eol_esm_cmd))
-    eol_esm_date = NOW + datetime.timedelta(days=eol_esm)
-    eol_esm_value = f"{eol_esm_date.month:02d}/{eol_esm_date.year}"
-    support["support"]["esm_until"] = eol_esm_value
+        eol_esm_cmd = base_cmd + ["--day=eol-esm"]
 
-    return support
+        eol_esm = int(self.process_run(eol_esm_cmd))
+        eol_esm_date = self.now + datetime.timedelta(days=eol_esm)
+        eol_esm_value = f"{eol_esm_date.month:02d}/{eol_esm_date.year}"
+        support["support"]["esm_until"] = eol_esm_value
 
+        return support
 
-def get_deprecated(series: str) -> Dict[str, Dict[str, object]]:
-    """
-    Calculated the deprecation date
-    and upgrade path for a deprecated release
-    """
-    logging.info(f"Getting support information for the {series}")
+    def get_deprecated(self, series: str) -> Dict[str, Dict[str, object]]:
+        """
+        Calculated the deprecation date
+        and upgrade path for a deprecated release
+        """
+        logging.info(f"Getting support information for the {series}")
 
-    eol_cmd = ["ubuntu-distro-info", "--series", series, "--day=eol"]
+        eol_cmd = ["ubuntu-distro-info", "--series", series, "--day=eol"]
 
-    eol = int(_process_run(eol_cmd))
-    eol_date = NOW + datetime.timedelta(days=eol)
-    # For now, the upgrade path is always the next release
+        eol = int(self.process_run(eol_cmd))
+        eol_date = self.now + datetime.timedelta(days=eol)
+        # For now, the upgrade path is always the next release
 
-    this_release_cmd = ["ubuntu-distro-info", "--series", series, "--day=release"]
-    this_release = int(_process_run(this_release_cmd))
-    # add 60 days to the release date, to get the next development version
-    next_date = NOW + datetime.timedelta(days=this_release + 60)
+        this_release_cmd = ["ubuntu-distro-info", "--series", series, "--day=release"]
+        this_release = int(self.process_run(this_release_cmd))
+        # add 60 days to the release date, to get the next development version
+        next_date = self.now + datetime.timedelta(days=this_release + 60)
 
-    following_dev_series_cmd = [
-        "ubuntu-distro-info",
-        "-d",
-        f"--date={next_date.year}-{next_date.month}-{next_date.day}",
-    ]
-    development_suite_at_eol = _process_run(following_dev_series_cmd)
+        following_dev_series_cmd = [
+            "ubuntu-distro-info",
+            "-d",
+            f"--date={next_date.year}-{next_date.month}-{next_date.day}",
+        ]
+        development_suite_at_eol = self.process_run(following_dev_series_cmd)
 
-    upgrade_path_cmd = [
-        "ubuntu-distro-info",
-        "--series",
-        development_suite_at_eol,
-        "-r",
-    ]
-    upgrade_path = _process_run(upgrade_path_cmd).strip(" LTS")
+        upgrade_path_cmd = [
+            "ubuntu-distro-info",
+            "--series",
+            development_suite_at_eol,
+            "-r",
+        ]
+        upgrade_path = self.process_run(upgrade_path_cmd).strip(" LTS")
 
-    return {
-        "deprecated": {
-            "date": f"{eol_date.month:02d}/{eol_date.year}",
-            "path": {"track": upgrade_path},
+        return {
+            "deprecated": {
+                "date": f"{eol_date.month:02d}/{eol_date.year}",
+                "path": {"track": upgrade_path},
+            }
         }
-    }
-
-
-def is_deprecated(series: str) -> bool:
-
-    """Checks whether a series is completely deprecated (both LTS and ESM)"""
-    logging.info(f"Checking is {series} is deprecated")
-    supported_cmd = "ubuntu-distro-info --supported"
-    supported_esm_cmd = supported_cmd + "-esm"
-    all_supported = _process_run(supported_cmd.split(" ")) + _process_run(
-        supported_esm_cmd.split(" ")
-    )
-    return series not in all_supported
-
 
-def is_lts(series: str) -> bool:
-
-    """Checks if a given series is LTS"""
-    logging.info(f"Checking is {series} is lts")
-
-    cmd = ["ubuntu-distro-info", "--series", series, "-f"]
-
-    return "LTS" in _process_run(cmd)
+    def is_deprecated(self, series: str) -> bool:
+        """Checks whether a series is completely deprecated (both LTS and ESM)"""
+        logging.info(f"Checking is {series} is deprecated")
+        supported_cmd = "ubuntu-distro-info --supported"
+        supported_esm_cmd = supported_cmd + "-esm"
+        all_supported = self.process_run(supported_cmd.split(" ")) + self.process_run(
+            supported_esm_cmd.split(" ")
+        )
+        return series not in all_supported
 
+    def is_lts(self, series: str) -> bool:
+        """Checks if a given series is LTS"""
+        logging.info(f"Checking is {series} is lts")
 
-def get_lowest_risk(tags: List[str]) -> str:
-    """
-    Get the lowest risk associated with the release
-    """
-    risk_sorted = ["stable", "candidate", "beta", "edge"]
+        cmd = ["ubuntu-distro-info", "--series", series, "-f"]
 
-    all_tags_str = " ".join(tags)
-    for risk in risk_sorted:
-        if risk in all_tags_str:
-            return risk
+        return "LTS" in self.process_run(cmd)
 
-    return "edge"
+    @staticmethod
+    def get_lowest_risk(tags: List[str]) -> str:
+        """
+        Get the lowest risk associated with the release
+        """
+        risk_sorted = ["stable", "candidate", "beta", "edge"]
 
+        all_tags_str = " ".join(tags)
+        for risk in risk_sorted:
+            if risk in all_tags_str:
+                return risk
 
-def get_release(series: str) -> str:
-    command = ["ubuntu-distro-info", f"--series={series}", "-r"]
+        return "edge"
 
-    return _process_run(command)
+    def get_release(self, series: str) -> str:
+        command = ["ubuntu-distro-info", f"--series={series}", "-r"]
 
+        return self.process_run(command)
 
-def infer_registry_user(
-    provider: str, username: str, password: str, dh_token: str = None
-) -> object:
-    user = None
-    if provider == "aws":
-        logging.info("Connecting to AWS")
-        session = boto3.Session(
-            region_name="us-east-1",
-            aws_access_key_id=username,
-            aws_secret_access_key=password,
-        )
-        user = session.client("ecr-public")
-    else:
-        logging.info("Fetching Docker Hub token")
-        if dh_token:
-            user = dh_token
-        else:
-            user = get_dockerhub_token(username, password)
-
-    return user
-
-
-def build_releases_data(
-    list_of_series: List[str],
-    all_tags: List[str],
-    image_url: str,
-    image_ns: str,
-    arguments: argparse.ArgumentParser.parse_args,
-    registry_user: object,
-) -> Dict:
-    """Build the releases info data structure"""
-    releases = []
-    for count, series in enumerate(list_of_series):
-        if series not in all_tags and series != arguments.unpublished_suite:
-            logging.warning(
-                f"Series {series} does not exist in {image_url}. Skipping it..."
+    def infer_registry_user(self) -> object:
+        user = None
+        if self.provider == "aws":
+            logging.info("Connecting to AWS")
+            session = boto3.Session(
+                region_name="us-east-1",
+                aws_access_key_id=self.username,
+                aws_secret_access_key=self.password,
             )
-            continue
-
-        release_data = {}
-
-        release = get_release(series)
-        if "LTS" in release:
-            release_data["type"] = "LTS"
-
-        release_data["track"] = release.rstrip(" LTS")
-
-        if arguments.unpublished_suite and arguments.unpublished_suite == series:
-            release_data["architectures"] = arguments.unpublished_archs.split()
-            release_data["version"] = get_fullname(arguments.unpublished_suite)
-            release_data["risk"] = get_lowest_risk(arguments.unpublished_tags.split())
-            release_data["tags"] = arguments.unpublished_tags.split()
+            user = session.client("ecr-public")
+            self._skopeo_auth_token = user.get_authorization_token()[
+                "authorizationData"
+            ]["authorizationToken"]
         else:
-            release_data["architectures"] = get_arches(series, image_url)
-            release_data["version"] = get_fullname(series)
-            if arguments.provider == "docker":
-                release_data["tags"] = get_tags_docker(
-                    series, registry_user, image_url, image_ns
-                )
+            logging.info("Fetching Docker Hub token")
+            if self.jwt_token_docker:
+                user = self.jwt_token_docker
             else:
-                release_data["tags"] = get_tags_aws(series, registry_user, image_url)
-            release_data["risk"] = get_lowest_risk(release_data["tags"])
-
-        if is_deprecated(series):
-            release_data["deprecated"] = get_deprecated(series)
-        else:
-            release_data["support"] = get_support(series, is_lts(series))
-
-        releases.append(release_data)
-
-    return releases
-
-
-def read_ubuntu_data_template() -> Dict:
-    """Reads and parses the YAML contents of the data template"""
-    template_file = f"{SCRIPT_DIR}/templates/ubuntu.yaml"
-    logging.info(f"Opening the template file {template_file}")
-    with open(template_file) as file:
-        try:
-            return yaml.safe_load(file)
-        except yaml.YAMLError as exc:
-            logging.error("Error when loading the ubuntu template file")
-            raise exc
-
-
-def create_data_dir(path: str):
-    """Create data dir if it doesn't exist"""
-    if not os.path.exists(path):
-        logging.info(f"Creating the {path} folder")
-
-        os.makedirs(path)
-
-
-def write_ubuntu_data_file(file_path: str, content: Dict):
-    """Write the YAML content into the ubuntu file path"""
-    with open(file_path, "w") as file:
-        logging.info(f"Create the yaml file {file_path}")
-        yaml.dump(content, file)
+                user = self.get_dockerhub_jwt_token()
+
+            self._skopeo_auth_token = base64.b64encode(
+                f"{self.username}:{self.password}".encode()
+            ).decode()
+
+        return user
+
+    def build_releases_data(
+        self,
+        list_of_series: List[str],
+        all_tags: List[str],
+        registry_user: object,
+    ) -> List[Dict]:
+        """Build the releases info data structure"""
+        releases = []
+        for count, series in enumerate(list_of_series):
+            if series not in all_tags and series != self.unpublished_suite:
+                logging.warning(
+                    f"Series {series} does not exist in {self.url}. Skipping it..."
+                )
+                continue
 
+            release_data = {}
 
-def main():
-    arguments = validate_args(cli_args())
-    registry_user = infer_registry_user(
-        arguments.provider,
-        arguments.username,
-        arguments.password,
-        arguments.dockertoken,
-    )
+            release = self.get_release(series)
+            if "LTS" in release:
+                release_data["type"] = "LTS"
 
-    add_yaml_representer()
-    url, ns = build_image_endpoint(arguments.provider, repo_base=arguments.repository)
+            release_data["track"] = release.rstrip(" LTS")
 
-    logging.info(f"Getting all tags from {url}")
-    command_tags = ["skopeo", "list-tags", url]
-    existing_tags = json.loads(_process_run(command_tags))["Tags"]
+            if self.unpublished_suite and self.unpublished_suite == series:
+                release_data["architectures"] = self.unpublished_archs.split()
+                release_data["version"] = self.get_fullname(self.unpublished_suite)
+                release_data["risk"] = self.get_lowest_risk(
+                    self.unpublished_tags.split()
+                )
+                release_data["tags"] = self.unpublished_tags.split()
+            else:
+                release_data["architectures"] = self.get_arches(series)
+                release_data["version"] = self.get_fullname(series)
+                if self.provider == "docker":
+                    release_data["tags"] = self.get_tags_docker(series, registry_user)
+                else:
+                    release_data["tags"] = self.get_tags_aws(series, registry_user)
+                release_data["risk"] = self.get_lowest_risk(release_data["tags"])
+
+            if self.is_deprecated(series):
+                release_data["deprecated"] = self.get_deprecated(series)
+            else:
+                release_data["support"] = self.get_support(series, self.is_lts(series))
+
+            releases.append(release_data)
+
+        return releases
+
+    @staticmethod
+    def read_ubuntu_data_template() -> Dict:
+        """Reads and parses the YAML contents of the data template"""
+        template_file = f"{SCRIPT_DIR}/templates/ubuntu.yaml"
+        logging.info(f"Opening the template file {template_file}")
+        with open(template_file) as file:
+            try:
+                return yaml.safe_load(file)
+            except yaml.YAMLError as exc:
+                logging.error("Error when loading the ubuntu template file")
+                raise exc
+
+    @staticmethod
+    def create_data_dir(path: str) -> None:
+        """Create data dir if it doesn't exist"""
+        if not os.path.exists(path):
+            logging.info(f"Creating the {path} folder")
+
+            os.makedirs(path)
+
+    @staticmethod
+    def write_ubuntu_data_file(file_path: str, content: Dict) -> None:
+        """Write the YAML content into the ubuntu file path"""
+        with open(file_path, "w") as file:
+            logging.info(f"Create the yaml file {file_path}")
+            yaml.dump(content, file)
+
+    def main(self) -> None:
+        registry_user = self.infer_registry_user()
+
+        logging.info(f"Getting all tags from {self.url}")
+
+        existing_tags = self.run_skopeo_command("list-tags", [f"docker://{self.url}"])[
+            "Tags"
+        ]
 
-    logging.info("Getting all the series from ubuntu-distro-info")
-    command_suites = ["ubuntu-distro-info", "--all"]
-    series_names = _process_run(command_suites).split("\n")
+        logging.info("Getting all the series from ubuntu-distro-info")
+        command_suites = ["ubuntu-distro-info", "--all"]
+        series_names = self.process_run(command_suites).split("\n")
 
-    if arguments.unpublished_suite and arguments.unpublished_suite not in series_names:
-        logging.error(
-            f"The provided unpublished suite {arguments.unpublished_suite}"
-            "is not recognized. Ignoring it"
-        )
+        if self.unpublished_suite and self.unpublished_suite not in series_names:
+            logging.error(
+                f"The provided unpublished suite {self.unpublished_suite}"
+                "is not recognized. Ignoring it"
+            )
 
-    logging.info("Building releases info")
-    releases = build_releases_data(
-        series_names, existing_tags, url, ns, arguments, registry_user
-    )
+        logging.info("Building releases info")
+        releases = self.build_releases_data(series_names, existing_tags, registry_user)
 
-    dict_file = read_ubuntu_data_template()
-    dict_file["releases"] = releases
+        dict_file = self.read_ubuntu_data_template()
+        dict_file["releases"] = releases
 
-    create_data_dir(arguments.data_dir)
+        self.create_data_dir(self.data_dir)
 
-    ubuntu_data_file = f"{arguments.data_dir}/ubuntu.yaml"
-    write_ubuntu_data_file(ubuntu_data_file, dict_file)
+        ubuntu_data_file = f"{self.data_dir}/ubuntu.yaml"
+        self.write_ubuntu_data_file(ubuntu_data_file, dict_file)
 
 
 if __name__ == "__main__":
-    main()
+    runner = GenerateUbuntuYaml()
+    runner.main()