rhdl 0.1.0.post1769067367__py3-none-any.whl

rhdl-0.1.0.post1769067367.dist-info/METADATA

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: rhdl
+Version: 0.1.0.post1769067367
+Summary: RHDL CLI module
+Home-page: https://doc.rhdl.distributed-ci.io/
+Author: Distributed CI team
+Author-email: distributed-ci@redhat.com
+License: Apache v2.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: rhdllib
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary

rhdl-0.1.0.post1769067367.dist-info/RECORD

@@ -0,0 +1,18 @@
+rhdl-0.1.0.post1769067367.dist-info/licenses/LICENSE,sha256=RVVnHNsitM_UrrOOZTEpvbjNHs-IZ4wgkeaWaYeNXRE,11337
+rhdlcli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rhdlcli/api.py,sha256=5CnTrM7LdwP6F9QCw7Bex66hP8mY3GR68nR4M5-F768,4608
+rhdlcli/cli.py,sha256=1JKBx89tNO5f44chYJBzZ8P1yF0yTyrdqerXLuD-Vsg,7195
+rhdlcli/downloader.py,sha256=cJ1UaWn6tUAiGTlaPu9xxhirWve_tggCu5tElNwaQjY,1435
+rhdlcli/files.py,sha256=SMYUn0aI4V9yueV6S-ymmbIrFf_gVQa0VSWVC_vqxBg,1560
+rhdlcli/fs.py,sha256=tEO-5EujnTLmKN-IsH6Vj6ePISGOgHvgyUTQG0wYR7M,544
+rhdlcli/main.py,sha256=6-_sMeh4RYBA5Y8hFX_hUSC3qOgHRh9ZjYaBjnMNbik,1270
+rhdlcli/options.py,sha256=RUj3xXgzIyrHJ-R2sFGBDUc-5SwcYKtBs_dJIWUn19Y,1746
+rhdlcli/pull_secret.py,sha256=iccyZRzlu4YAvyjroqRquWwFnI0rIytjpstAY0n5Ye0,1207
+rhdlcli/stats.py,sha256=MvwxMr4LAm3PM5qiEnuB8thUgzBolWPLKg6ql53QU_Y,786
+rhdlcli/validator.py,sha256=zpX_f1g2UeDUjFk0a7HzR3YydryC3k9QgaUc2C1Lp4g,950
+rhdlcli/version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+rhdl-0.1.0.post1769067367.dist-info/METADATA,sha256=c2fAXlFWR8_FqhzmJnbZMWBEWkP6iZmxdMND_KifH4A,607
+rhdl-0.1.0.post1769067367.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+rhdl-0.1.0.post1769067367.dist-info/entry_points.txt,sha256=JWiBdHm5nD1m3_XZR0QtIuPmuvsJKE-43YhQxCINb8w,43
+rhdl-0.1.0.post1769067367.dist-info/top_level.txt,sha256=1kLkHuRFxHGxPUkrCL28sF6wqXmu3IGhJT858T4XRaI,8
+rhdl-0.1.0.post1769067367.dist-info/RECORD,,

rhdl-0.1.0.post1769067367.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

rhdl-0.1.0.post1769067367.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+rhdl = rhdlcli.main:main

rhdl-0.1.0.post1769067367.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2019 Red Hat
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

rhdl-0.1.0.post1769067367.dist-info/top_level.txt

@@ -0,0 +1 @@
+rhdlcli

rhdlcli/api.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import os
+import requests
+import sys
+import time
+
+from concurrent.futures import ThreadPoolExecutor
+from functools import wraps
+from urllib.parse import urljoin
+from rhdlcli.fs import create_parent_dir
+from rhdllib.auth import HmacAuthBase
+
+FIVE_SECONDS = 5
+TEN_SECONDS = 10
+# We'll allow 5 seconds to connect & 10 seconds to get an answer
+REQUESTS_TIMEOUT = (FIVE_SECONDS, TEN_SECONDS)
+
+
+class HmacSession(requests.Session):
+    def __init__(self, base_url, access_key, secret_key):
+        self.base_url = base_url
+        self.access_key = access_key
+        self.secret_key = secret_key
+        super(HmacSession, self).__init__()
+
+    def request(self, method, url, *args, allow_redirects=True, **kwargs):
+        url = urljoin(self.base_url, url)
+        auth = HmacAuthBase(
+            self.access_key, self.secret_key, service="api", region="us-east-1"
+        )
+        response = super(HmacSession, self).request(
+            method, url, auth=auth, allow_redirects=False, *args, **kwargs
+        )
+        if response.status_code == 302 and allow_redirects:
+            redirect_url = response.headers.get("Location")
+            return super(HmacSession, self).request(
+                method, redirect_url, *args, **kwargs
+            )
+        return response
+
+
+def retry(tries=3, delay=2, multiplier=2):
+    def decorated_retry(f):
+        @wraps(f)
+        def f_retry(*args, **kwargs):
+            _tries = tries
+            _delay = delay
+            while _tries:
+                try:
+                    return f(*args, **kwargs)
+                except KeyboardInterrupt:
+                    raise
+                except Exception as e:
+                    print("%s, retrying in %d seconds..." % (str(e), _delay))
+                    time.sleep(_delay)
+                    _tries -= 1
+                    if not _tries:
+                        raise
+                    _delay *= multiplier
+            return f(*args, **kwargs)
+
+        return f_retry
+
+    return decorated_retry
+
+
+def get_component(options):
+    session = HmacSession(
+        base_url=options["base_url"],
+        access_key=options["access_key"],
+        secret_key=options["secret_key"],
+    )
+    compose = options["compose"]
+    r = session.get(
+        f"/api/v1/components?compose_id_startswith={compose}&state=active&sort=-released_at"
+    )
+    r.raise_for_status()
+    components = r.json()["components"]
+    if len(components) <= 0:
+        print(f"No component found with compose id starting with {compose}")
+        sys.exit(1)
+    return components[0]
+
+
+@retry()
+def get_files_list(session):
+    print("Download file list, it may take a few seconds")
+    r = session.get("rhdl_files_list.json")
+    r.raise_for_status()
+    return r.json()
+
+
+@retry()
+def download_file(session, download_folder, file, i, nb_files):
+    start_time = time.monotonic()
+    relative_file_path = os.path.join(file["path"], file["name"])
+    destination = os.path.join(download_folder, relative_file_path)
+    if os.path.exists(destination):
+        print(f"({i + 1}/{nb_files}): < Skipping {destination} file already exists")
+        return
+    print(f"({i + 1}/{nb_files}): < Getting {destination}")
+    create_parent_dir(destination)
+    r = session.get(relative_file_path)
+    r.raise_for_status()
+    with open(destination, "wb") as f:
+        for chunk in r.iter_content(chunk_size=1024 * 1024):
+            f.write(chunk)
+    download_speed = round(file["size"] / (time.monotonic() - start_time) / 1024, 2)
+    print(f"({i + 1}/{nb_files}): > Done {destination} - {download_speed} KB/s")
+    return file
+
+
+def download_files(session, download_folder, files):
+    nb_files = len(files)
+    with ThreadPoolExecutor(max_workers=10) as executor:
+        for file in executor.map(
+            download_file,
+            *zip(
+                *[
+                    (session, download_folder, file, i, nb_files)
+                    for i, file in enumerate(files)
+                ]
+            ),
+        ):
+            pass
+
+
+def get_pull_secret(options):
+    session = HmacSession(
+        base_url=options["base_url"],
+        access_key=options["access_key"],
+        secret_key=options["secret_key"],
+    )
+    r = session.get("/api/v1/teams/me/pull_secret")
+    r.raise_for_status()
+    pull_secret = r.json()["pull_secret"]
+    if pull_secret is None:
+        print(
+            "Your team currently does not have access to the Red Hat registry."
+            "Please reach out to an RHDL administrator for assistance."
+        )
+        sys.exit(1)
+    return pull_secret

rhdlcli/cli.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import argparse
+import os
+import pathlib
+
+from rhdlcli.version import __version__
+
+DESCRIPTION = "RHDL CLI - Download the latest RHEL compose easily."
+
+COPYRIGHT = """
+Copyright © 2026 Red Hat.
+Licensed under the Apache License, Version 2.0
+"""
+
+
+def clean_with_default_values(parsed_arguments, cwd):
+    args_dict = vars(parsed_arguments)
+
+    if args_dict.get("command") == "download":
+        DEFAULT_INCLUDE_EXCLUDE_LIST = [
+            {"pattern": ".composeinfo", "type": "include"},
+            {"pattern": "metadata/*", "type": "include"},
+            {"pattern": "AppStream/x86_64/os/*", "type": "include"},
+            {"pattern": "BaseOS/x86_64/os/*", "type": "include"},
+            {"pattern": "*", "type": "exclude"},
+        ]
+        if "include_and_exclude" not in args_dict:
+            args_dict["include_and_exclude"] = DEFAULT_INCLUDE_EXCLUDE_LIST
+
+        if "include" in args_dict:
+            del args_dict["include"]
+        if "exclude" in args_dict:
+            del args_dict["exclude"]
+
+        if args_dict.get("destination") is None:
+            base_path = pathlib.Path(cwd)
+        else:
+            base_path = pathlib.Path(cwd, args_dict["destination"]).resolve()
+
+        if not args_dict["flat"]:
+            base_path = base_path / args_dict["compose"]
+
+        args_dict["destination"] = os.fspath(base_path)
+
+    return args_dict
+
+
+class IncludeExcludeAction(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        if "include_and_exclude" not in namespace:
+            setattr(namespace, "include_and_exclude", [])
+        previous = namespace.include_and_exclude
+        previous.append({"pattern": values, "type": self.dest})
+        setattr(namespace, "include_and_exclude", previous)
+
+
+def add_login_command(subparsers):
+    """Add the login subcommand"""
+    login_parser = subparsers.add_parser(
+        "login",
+        help="Login to RHDL",
+        description="Authenticate with RHDL to access compose downloads.",
+        epilog=COPYRIGHT,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    login_parser.set_defaults(command="login")
+
+
+def add_download_command(subparsers):
+    """Add the download subcommand"""
+    download_examples = """
+examples:
+  # Download latest RHEL-10 compose in <cwd>/RHEL-10 folder
+  rhdl download RHEL-10
+
+  # Download latest RHEL-10 in /tmp/repo/RHEL-10 folder
+  rhdl download RHEL-10 --destination /tmp/repo
+
+  # Download directly in /tmp/repo/RHEL-10 without creating RHEL-10 subdirectory
+  rhdl download RHEL-10 --destination /tmp/repo/RHEL-10 --flat
+
+  # Download with custom include/exclude patterns
+  rhdl download RHEL-10 --include "*/x86_64/*" --exclude "*/debug/*"
+
+  # Download specific tag (nightly, candidate, ga)
+  rhdl download RHEL-10 --tag nightly
+"""
+    download_parser = subparsers.add_parser(
+        "download",
+        help="Download a RHEL compose",
+        description="Download a specific RHEL compose with filtering options.",
+        epilog=download_examples + COPYRIGHT,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    download_parser.add_argument(
+        "compose", metavar="COMPOSE", help="Compose ID or NAME (e.g., RHEL-10)"
+    )
+    download_parser.add_argument(
+        "-d",
+        "--destination",
+        metavar="DESTINATION",
+        help="Destination folder where a <COMPOSE> subdirectory will be created (default: current directory)",
+    )
+    download_parser.add_argument(
+        "--flat",
+        action="store_true",
+        default=False,
+        help="Download directly into destination folder without creating a subdirectory with the Compose ID",
+    )
+    download_parser.add_argument(
+        "-f",
+        "--force",
+        action="store_true",
+        default=False,
+        help="Force download even if destination folder already exists",
+    )
+    download_parser.add_argument(
+        "-i",
+        "--include",
+        action=IncludeExcludeAction,
+        metavar="PATTERN",
+        dest="include",
+        help="File paths pattern to download. Wildcard '*' authorized. Can be used multiple times.",
+    )
+    download_parser.add_argument(
+        "-e",
+        "--exclude",
+        action=IncludeExcludeAction,
+        metavar="PATTERN",
+        dest="exclude",
+        help="File paths pattern to exclude. Wildcard '*' authorized. Can be used multiple times.",
+    )
+    download_parser.add_argument(
+        "-t",
+        "--tag",
+        metavar="TAG",
+        default="milestone",
+        help="Filter RHEL compose with a tag (choices: milestone, nightly, candidate, ga) (default: milestone)",
+    )
+    download_parser.set_defaults(command="download")
+
+
+def add_download_pull_secret_command(subparsers):
+    """Add the download-pull-secret subcommand"""
+    pull_secret_examples = """
+examples:
+  # Download pull-secret to default location (~/.docker/config.json)
+  rhdl download-pull-secret
+
+  # Download pull-secret to custom location
+  rhdl download-pull-secret --destination ./my-pull-secret.json
+
+  # Force overwrite existing file
+  rhdl download-pull-secret --force
+
+  # Merge with existing pull-secret
+  rhdl download-pull-secret --merge
+"""
+    pull_secret_parser = subparsers.add_parser(
+        "download-pull-secret",
+        help="Download your team's pull-secret",
+        description="Download the pull-secret associated with your team for authenticating to container registries.",
+        epilog=pull_secret_examples + COPYRIGHT,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    pull_secret_parser.add_argument(
+        "-d",
+        "--destination",
+        metavar="PATH",
+        default=os.path.expanduser("~/.docker/config.json"),
+        help="Destination file path for the pull-secret (default: ~/.docker/config.json)",
+    )
+    pull_secret_parser.add_argument(
+        "-f",
+        "--force",
+        action="store_true",
+        default=False,
+        help="Force overwrite if destination file already exists",
+    )
+    pull_secret_parser.add_argument(
+        "-m",
+        "--merge",
+        action="store_true",
+        default=False,
+        help="Merge with existing pull-secret instead of replacing it",
+    )
+    pull_secret_parser.set_defaults(command="download-pull-secret")
+
+
+def parse_arguments(arguments, cwd=None):
+    cwd = cwd or os.getcwd()
+    parser = argparse.ArgumentParser(
+        prog="rhdl",
+        description=DESCRIPTION,
+        epilog=COPYRIGHT,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("--version", action="version", version=__version__)
+
+    subparsers = parser.add_subparsers(
+        title="commands",
+        description="Available commands",
+        dest="command",
+        help="Use 'rhdl COMMAND --help' for more information on a command",
+    )
+
+    add_login_command(subparsers)
+    add_download_command(subparsers)
+    add_download_pull_secret_command(subparsers)
+
+    parsed_arguments = parser.parse_args(arguments)
+
+    if parsed_arguments.command is None:
+        parser.print_help()
+        raise SystemExit(1)
+
+    return clean_with_default_values(parsed_arguments, cwd)

rhdlcli/downloader.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import os
+from urllib.parse import urljoin
+from rhdlcli.api import (
+    get_component,
+    get_files_list,
+    download_files,
+    HmacSession,
+)
+from rhdlcli.stats import check_download_folder_has_enough_space
+from rhdlcli.files import get_files_to_remove, filter_files
+from rhdlcli.fs import mkdir_p
+
+
+def clean_download_folder(download_folder, files):
+    print("Verifying local mirror, this may take some time")
+
+    if not os.path.isdir(download_folder):
+        mkdir_p(download_folder)
+
+    for file in get_files_to_remove(download_folder, files):
+        print(f"Remove file {file}")
+        os.remove(file)
+
+
+def download_component(options):
+    component = get_component(options)
+    print(
+        f"Downloading component: {component['compose_id']} in {options['destination']}"
+    )
+    session = HmacSession(
+        base_url=urljoin(
+            options["base_url"], f"/api/v1/components/{component['compose_id']}/files/"
+        ),
+        access_key=options["access_key"],
+        secret_key=options["secret_key"],
+    )
+    files_list = get_files_list(session)
+    files = files_list["files"]
+    files = filter_files(files, options["include_and_exclude"])
+    download_folder = options["destination"]
+    clean_download_folder(download_folder, files)
+    check_download_folder_has_enough_space(download_folder, files)
+    download_files(session, download_folder, files)

rhdlcli/files.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import fnmatch
+import hashlib
+import os
+
+
+def _sha256_hexdigest_file(filepath):
+    m = hashlib.sha256()
+    with open(filepath, mode="rb") as fd:
+        for data in fd:
+            m.update(data)
+    return m.hexdigest()
+
+
+def _file_clean(file_path, sha256):
+    return _sha256_hexdigest_file(file_path) == sha256
+
+
+def get_files_to_remove(download_folder, files):
+    files_list_paths = {}
+    for file in files:
+        file_path = os.path.join(download_folder, file["path"], file["name"])
+        files_list_paths[file_path] = file
+    files_to_remove = []
+    for root, dirs, files in os.walk(download_folder):
+        for file in files:
+            file_path = os.path.join(root, file)
+            if os.path.islink(file_path):
+                continue
+            if file_path not in files_list_paths or not _file_clean(
+                file_path, files_list_paths[file_path]["sha256"]
+            ):
+                files_to_remove.append(file_path)
+    return files_to_remove
+
+
+def filter_files(files, include_and_exclude):
+    new_files = []
+    for file in files:
+        relative_path = os.path.join(file["path"], file["name"])
+        matching_pattern = False
+        for ie in include_and_exclude:
+            if fnmatch.fnmatch(relative_path, ie["pattern"]):
+                matching_pattern = True
+                if ie["type"] == "include":
+                    new_files.append(file)
+                break
+        if not matching_pattern:
+            new_files.append(file)
+
+    return new_files

rhdlcli/fs.py

@@ -0,0 +1,23 @@
+import errno
+import os
+
+
+def mkdir_p(path):
+    try:
+        os.makedirs(path)
+    except OSError as exc:
+        if exc.errno == errno.EEXIST and os.path.isdir(path):
+            pass
+        elif exc.errno in [errno.EPERM, errno.EACCES]:
+            print(f"Permission error on {path}")
+        else:
+            raise
+
+
+def create_parent_dir(path):
+    mkdir_p(os.path.dirname(path))
+
+
+def get_config_path(env_variables):
+    path = env_variables.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config"))
+    return os.path.join(path, "rhdl")

rhdlcli/main.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import functools
+import os
+import sys
+
+from rhdlcli.cli import parse_arguments
+from rhdlcli.downloader import download_component
+from rhdlcli.pull_secret import download_pull_secret
+from rhdlcli.options import build_options, login
+from rhdlcli.validator import (
+    exit_if_credentials_invalid,
+    exit_if_destination_exists,
+)
+
+
+def catch_all_and_print(f):
+    @functools.wraps(f)
+    def inner(*args, **kwargs):
+        try:
+            return f(*args, **kwargs)
+        except KeyboardInterrupt:
+            print("Keyboard interrupt exiting...")
+            sys.exit(130)
+        except Exception as e:
+            print(e)
+            sys.exit(1)
+
+    return inner
+
+
+@catch_all_and_print
+def main():
+    cwd = os.path.realpath(os.getcwd())
+    arguments = parse_arguments(sys.argv[1:], cwd)
+    env_variables = dict(os.environ)
+    options = build_options(arguments, env_variables)
+    if options["command"] == "login":
+        login(options)
+        return
+    exit_if_credentials_invalid(options)
+    if options["command"] == "download-pull-secret":
+        download_pull_secret(options)
+        return
+    exit_if_destination_exists(options)
+    download_component(options)
+
+
+if __name__ == "__main__":
+    main()

rhdlcli/options.py

@@ -0,0 +1,57 @@
+import getpass
+import json
+import os
+
+from rhdlcli.fs import get_config_path
+
+CREDENTIAL_FILE_NAME = "credentials.json"
+
+
+def read_credentials_file(app_config_path):
+    credential_file_path = os.path.join(app_config_path, CREDENTIAL_FILE_NAME)
+    if not os.path.isfile(credential_file_path):
+
+        return {}
+    with open(credential_file_path) as f:
+        return json.load(f)
+
+
+def build_options(arguments, env_variables):
+    options = {}
+    options.update(arguments)
+    app_config_path = get_config_path(env_variables)
+    credentials = read_credentials_file(app_config_path)
+    options.update(
+        {
+            "app_config_path": app_config_path,
+            "base_url": env_variables.get("RHDL_API_URL", credentials.get("base_url")),
+            "access_key": env_variables.get(
+                "RHDL_ACCESS_KEY", credentials.get("access_key")
+            ),
+            "secret_key": env_variables.get(
+                "RHDL_SECRET_KEY", credentials.get("secret_key")
+            ),
+        }
+    )
+    return options
+
+
+def login(options):
+    app_config_path = options["app_config_path"]
+    if not os.path.exists(app_config_path):
+        os.makedirs(app_config_path)
+
+    access_key = input("RHDL Access Key: ")
+    secret_key = getpass.getpass("RHDL Secret Key: ")
+    default_base_url = "https://api.rhdl.distributed-ci.io"
+    base_url = input(f"RHDL server host ({default_base_url}):") or default_base_url
+    credentials = {
+        "base_url": base_url,
+        "access_key": access_key,
+        "secret_key": secret_key,
+    }
+
+    file_path = os.path.join(app_config_path, CREDENTIAL_FILE_NAME)
+    with open(file_path, "w") as f:
+        json.dump(credentials, f)
+        print(f"Credential saved in {file_path}")

rhdlcli/pull_secret.py

@@ -0,0 +1,38 @@
+import json
+import os
+from rhdlcli.api import get_pull_secret
+
+
+def download_pull_secret(options):
+    destination = options["destination"]
+    force = options["force"]
+    merge = options["merge"]
+
+    if os.path.exists(destination) and not force and not merge:
+        raise FileExistsError(
+            f"File {destination} already exists. Use --force or --merge to overwrite."
+        )
+
+    pull_secret = get_pull_secret(options)
+
+    if merge and os.path.exists(destination):
+        with open(destination, "r") as f:
+            existing_data = json.load(f)
+        new_data = json.loads(pull_secret)
+
+        existing_keys = set(existing_data["auths"].keys())
+        new_keys = set(new_data["auths"].keys())
+        conflicting_keys = existing_keys & new_keys
+
+        if conflicting_keys and not force:
+            raise FileExistsError(
+                f"Keys {','.join(conflicting_keys)} already exists in {destination}. Use --force to overwrite."
+            )
+
+        existing_data["auths"].update(new_data["auths"])
+
+        with open(destination, "w") as f:
+            f.write(json.dumps(existing_data))
+    else:
+        with open(destination, "w") as f:
+            f.write(pull_secret)

rhdlcli/stats.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import os
+
+
+def get_component_size(files):
+    size = 0
+    for file in files:
+        size += file["size"]
+    return size
+
+
+def enough_space(download_folder, files):
+    component_size = get_component_size(files)
+    st = os.statvfs(download_folder)
+    free_space = st.f_bavail * st.f_frsize * 0.95
+    component_size_gb = component_size / 1024 / 1024 / 1024
+    free_space_gb = free_space / 1024 / 1024 / 1024
+    print("Component size %d GB" % component_size_gb)
+    print("Free space %d GB" % free_space_gb)
+    return component_size < free_space
+
+
+def check_download_folder_has_enough_space(download_folder, files):
+    if not enough_space(download_folder, files):
+        raise Exception("Not enough space in %s" % download_folder)

rhdlcli/validator.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import os
+import sys
+
+
+def credentials_are_defined(options):
+    required_keys = ["base_url", "access_key", "secret_key"]
+    return all(key in options and options[key] is not None for key in required_keys)
+
+
+def exit_if_credentials_invalid(options):
+    if not credentials_are_defined(options):
+        print("Credentials are invalid. Run `rhdl login` or set env variables.")
+        sys.exit(1)
+
+
+def destination_folder_exists(options):
+    destination = options["destination"]
+    if destination and os.path.exists(destination):
+        return True
+    return False
+
+
+def exit_if_destination_exists(options):
+    if destination_folder_exists(options) and not options["force"]:
+        destination = options["destination"]
+        print(
+            f"Error: Destination folder already exists: {destination}\n"
+            f"Use --force to overwrite the existing folder."
+        )
+        sys.exit(1)

rhdlcli/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"