move to warnings object

Author: kieranmanning

cloudsmith_cli/cli/commands/main.py

@@ -2,6 +2,8 @@
 
 import click
 
+from cloudsmith_cli.cli.warnings import get_or_create_warnings
+
 from ...core.api.version import get_version as get_api_version
 from ...core.utils import get_github_website, get_help_website
 from ...core.version import get_version as get_cli_version
@@ -61,3 +63,13 @@ def main(ctx, opts, version):
         print_version()
     elif ctx.invoked_subcommand is None:
         click.echo(ctx.get_help())
+
+
+@main.result_callback()
+@click.pass_context
+def result_callback(ctx, opts, **kwargs):
+    """Callback for main function. Required for saving warnings til the end."""
+
+    warnings = get_or_create_warnings(ctx)
+    if warnings:
+        click.echo(warnings.report())

cloudsmith_cli/cli/commands/repos.py

@@ -101,9 +101,6 @@ def get(ctx, opts, owner_repo, page, page_size):
 
     click.echo("Getting list of repositories ... ", nl=False, err=use_stderr)
 
-    repo = None
-    owner = None
-
     if isinstance(owner_repo, list):
         if len(owner_repo) == 1:
             owner = owner_repo[0]

cloudsmith_cli/cli/config.py

@@ -7,6 +7,8 @@
 import click
 from click_configfile import ConfigFileReader, Param, SectionSchema, matches_section
 
+from cloudsmith_cli.cli.warnings import ConfigLoadWarning, ProfileNotFoundWarning
+
 from ..core.utils import get_data_path, read_file
 from . import utils, validators
 
@@ -162,8 +164,9 @@ def config_already_warned(cls):
         return False
 
     @classmethod
-    def load_config(cls, opts, path=None, profile=None, no_warn=False):
+    def load_config(cls, opts, path=None, warnings=None, profile=None):
         """Load a configuration file into an options object."""
+
         if path and os.path.exists(path):
             if os.path.isdir(path):
                 cls.config_searchpath.insert(0, path)
@@ -174,36 +177,22 @@ def load_config(cls, opts, path=None, profile=None, no_warn=False):
         values = config.get("default", {})
         cls._load_values_into_opts(opts, values)
 
-        warn = not no_warn and not cls.config_already_warned()
-
-        if profile and profile != "default" and warn:
+        if profile and profile != "default":
             try:
                 values = config["profile:%s" % profile]
                 cls._load_values_into_opts(opts, values)
             except KeyError:
-                if warn:
-                    click.secho(
-                        f"Warning: profile {profile} not found in config files {cls.config_files}",
-                        fg="yellow",
-                    )
+                warning = ProfileNotFoundWarning(path=path, profile=profile)
+                warnings.append(warning)
 
         existing_config_paths = {
             path: os.path.exists(path) for path in cls.config_files
         }
-        if not any(existing_config_paths.values()) and warn:
-            click.secho(
-                "Warning: No config files found in search paths. Tried the following:",
-                fg="yellow",
-            )
-            for tested_path, exists in existing_config_paths.items():
-                if exists:
-                    click.secho(f"{tested_path} - file exists", fg="green")
-                else:
-                    click.secho(f"{tested_path} - file does not exist", fg="yellow")
-            click.secho(
-                "You may need to run `cloudsmith login` to authenticate and create a config file.",
-                fg="yellow",
+        if not any(list(existing_config_paths.values())):
+            config_load_warning = ConfigLoadWarning(
+                paths=existing_config_paths,
             )
+            warnings.append(config_load_warning)
 
         return values
 
@@ -248,7 +237,7 @@ class CredentialsReader(ConfigReader):
     config_section_schemas = [CredentialsSchema.Default, CredentialsSchema.Profile]
 
     @classmethod
-    def load_config(cls, opts, path=None, profile=None, no_warn=False):
+    def load_config(cls, opts, path=None, warnings=None, profile=None):
         """
         Load a credentials configuration file into an options object.
         We overload the load_config command in CredentialsReader as
@@ -292,15 +281,17 @@ def get_creds_reader():
         """Get the credentials config reader class."""
         return CredentialsReader
 
-    def load_config_file(self, path, profile=None, no_warn=False):
+    def load_config_file(self, path, warnings=None, profile=None):
         """Load the standard config file."""
+        print("load_config_file")
         config_cls = self.get_config_reader()
-        return config_cls.load_config(self, path, profile=profile, no_warn=no_warn)
+        return config_cls.load_config(self, path, warnings=warnings, profile=profile)
 
-    def load_creds_file(self, path, profile=None, no_warn=False):
+    def load_creds_file(self, path, warnings=None, profile=None):
         """Load the credentials config file."""
+        print("load_creds_file")
         config_cls = self.get_creds_reader()
-        return config_cls.load_config(self, path, profile=profile, no_warn=no_warn)
+        return config_cls.load_config(self, path, warnings=warnings, profile=profile)
 
     @property
     def api_config(self):

cloudsmith_cli/cli/decorators.py

@@ -4,6 +4,8 @@
 
 import click
 
+from cloudsmith_cli.cli.warnings import ApiAuthenticationWarning, get_or_create_warnings
+
 from ..core.api.init import initialise_api as _initialise_api
 from ..core.api.user import get_user_brief
 from . import config, utils, validators
@@ -87,25 +89,17 @@ def common_cli_config_options(f):
         envvar="CLOUDSMITH_PROFILE",
         help="The name of the profile to use for configuration.",
     )
-    @click.option(
-        "--no-warn",
-        is_flag=True,
-        default=None,
-        help="Don't warn on misconfiguration issues",
-    )
     @click.pass_context
     @functools.wraps(f)
     def wrapper(ctx, *args, **kwargs):
         # pylint: disable=missing-docstring
         opts = config.get_or_create_options(ctx)
+        warnings = get_or_create_warnings(ctx)
         profile = kwargs.pop("profile")
         config_file = kwargs.pop("config_file")
         creds_file = kwargs.pop("credentials_file")
-        no_warn = kwargs.pop("no_warn")
-        if no_warn:
-            opts.no_warn = no_warn
-        opts.load_config_file(path=config_file, profile=profile, no_warn=opts.no_warn)
-        opts.load_creds_file(path=creds_file, profile=profile, no_warn=opts.no_warn)
+        opts.load_config_file(path=config_file, profile=profile, warnings=warnings)
+        opts.load_creds_file(path=creds_file, profile=profile, warnings=warnings)
         kwargs["opts"] = opts
         return ctx.invoke(f, *args, **kwargs)
 
@@ -316,20 +310,11 @@ def call_print_rate_limit_info_with_opts(rate_info):
         )
 
         cloudsmith_host = kwargs["opts"].opts["api_config"].host
-        no_warn = opts.no_warn
         is_auth, _, _, _ = get_user_brief()
-        if not is_auth and not no_warn:
-            click.secho(
-                "Warning: You are not authenticated with the API. "
-                "Please verify your config files, API key and "
-                "run `cloudsmith login` if necessary to authenticate.",
-                fg="yellow",
-            )
-            click.secho(
-                f"You're currently attempting to connect to Cloudsmith instance {cloudsmith_host}",
-                fg="yellow",
-            )
-            opts.no_warn = True
+        if not is_auth:
+            warnings = get_or_create_warnings(ctx)
+            auth_warning = ApiAuthenticationWarning(cloudsmith_host)
+            warnings.append(auth_warning)
 
         kwargs["opts"] = opts
         return ctx.invoke(f, *args, **kwargs)

cloudsmith_cli/cli/warnings.py

@@ -0,0 +1,97 @@
+from abc import ABC
+from typing import Dict, List
+
+
+class CliWarning(ABC):
+    """
+    Abstract base class for all Cloudsmith CLI warnings.
+    """
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __str__(self):
+        return f"{self.__class__.__name__}"
+
+
+class ConfigLoadWarning(CliWarning):
+    """
+    Warning for issues loading the configuration file.
+    """
+
+    def __init__(self, paths: Dict[str, bool]):
+        self.paths = paths
+        self.message = "Failed to load config files. Tried the following paths: \n"
+        for path, exists in paths.items():
+            self.message += f"  - {path} - exists: {exists})\n"
+        self.message += "You may need to run `cloudsmith login` to authenticate and create a config file."
+
+    def __str__(self):
+        return f"{self.__class__.__name__} - {self.paths}"
+
+
+class ProfileNotFoundWarning(CliWarning):
+    """
+    Warning for issues loading the configuration file.
+    """
+
+    def __init__(self, path, profile):
+        self.path = path
+        self.profile = profile
+        self.message = f"Failed to load config file: {path} for profile: {profile}"
+
+    def __str__(self):
+        return f"{self.__class__.__name__} - {self.path} - {self.profile}"
+
+
+class ApiAuthenticationWarning(CliWarning):
+    """
+    Warning for issues with API authentication.
+    """
+
+    def __init__(self, cloudsmith_host):
+        self.cloudsmith_host = cloudsmith_host
+        self.message = "\n".join(
+            [
+                "Failed to authenticate with Cloudsmith API",
+                "Please check your credentials and try again",
+                f"Host: {cloudsmith_host}",
+            ]
+        )
+
+    def __str__(self):
+        return f"{self.__class__.__name__} - {self.cloudsmith_host}"
+
+
+class CliWarnings(list):
+    """
+    A class to manage warnings in the CLI.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.warnings: List[CliWarning] = []
+
+    def append(self, warning: CliWarning):
+        self.warnings.append(warning)
+
+    def __dedupe__(self) -> List[CliWarning]:
+        return list(set(self.warnings))
+
+    def report(self) -> List[CliWarning]:
+        return self.__dedupe__()
+
+    def __str__(self) -> str:
+        return ",".join([str(x) for x in self.warnings])
+
+    def __repr__(self) -> str:
+        return ",".join([str(x) for x in self.warnings])
+
+    def __len__(self) -> int:
+        return len(self.warnings)
+
+
+def get_or_create_warnings(ctx):
+    """Get or create the options object."""
+
+    return ctx.ensure_object(CliWarnings)