Add core:warnings_as_errors configuration option

conan/api/output.py

@@ -51,6 +51,7 @@ class ConanOutput:
     # Singleton
     _conan_output_level = LEVEL_STATUS
     _silent_warn_tags = []
+    _warnings_as_errors = False
 
     def __init__(self, scope=""):
         self.stream = sys.stderr
@@ -63,6 +64,10 @@ def __init__(self, scope=""):
     def define_silence_warnings(cls, warnings):
         cls._silent_warn_tags = warnings or []
 
+    @classmethod
+    def set_warnings_as_errors(cls, value):
+        cls._warnings_as_errors = value
+
     @classmethod
     def define_log_level(cls, v):
         """
@@ -204,16 +209,27 @@ def success(self, msg):
         return self
 
     def warning(self, msg, warn_tag=None):
-        if self._conan_output_level <= LEVEL_WARNING:
-            if warn_tag is not None and warn_tag in self._silent_warn_tags:
+        def _skip_warning():
+            return (warn_tag is not None and warn_tag in self._silent_warn_tags
+                    or warn_tag is None and "unknown" in self._silent_warn_tags)
+        if self._conan_output_level <= LEVEL_WARNING or (self._warnings_as_errors and self._conan_output_level <= LEVEL_ERROR):
+            if _skip_warning():
                 return self
             warn_tag_msg = "" if warn_tag is None else f"{warn_tag}: "
-            self._write_message(f"WARN: {warn_tag_msg}{msg}", Color.YELLOW)
+            output = f"{warn_tag_msg}{msg}"
+
+            if self._warnings_as_errors:
+                self.error(output)
+            else:
+                self._write_message(f"WARN: {output}", Color.YELLOW)
         return self
 
-    def error(self, msg):
+    def error(self, msg, error_type=None):
         if self._conan_output_level <= LEVEL_ERROR:
-            self._write_message("ERROR: {}".format(msg), Color.RED)
+            if self._warnings_as_errors and error_type != "context":
+                raise ConanException(msg)
+            else:
+                self._write_message("ERROR: {}".format(msg), Color.RED)
         return self
 
     def flush(self):

conan/cli/cli.py

@@ -51,8 +51,8 @@ def _add_commands(self):
                 try:
                     self._add_command(module_name, module_name.replace("cmd_", ""))
                 except Exception as e:
-                    ConanOutput().error("Error loading custom command "
-                                        "'{}.py': {}".format(module_name, e))
+                    ConanOutput().error(f"Error loading custom command '{module_name}.py': {e}",
+                                        error_type="context")
         # layers
         for folder in os.listdir(custom_commands_path):
             layer_folder = os.path.join(custom_commands_path, folder)
@@ -67,7 +67,8 @@ def _add_commands(self):
                         self._add_command(module_path, module_name.replace("cmd_", ""),
                                           package=folder)
                     except Exception as e:
-                        ConanOutput().error(f"Error loading custom command {module_path}: {e}")
+                        ConanOutput().error(f"Error loading custom command {module_path}: {e}",
+                                            error_type="context")
 
     def _add_command(self, import_path, method_name, package=None):
         try:
@@ -208,20 +209,20 @@ def exception_exit_error(exception):
         if exception is None:
             return SUCCESS
         if isinstance(exception, ConanInvalidConfiguration):
-            output.error(exception)
+            output.error(exception, error_type="context")
             return ERROR_INVALID_CONFIGURATION
         if isinstance(exception, ConanException):
-            output.error(exception)
+            output.error(exception, error_type="context")
             return ERROR_GENERAL
         if isinstance(exception, SystemExit):
             if exception.code != 0:
-                output.error("Exiting with code: %d" % exception.code)
+                output.error("Exiting with code: %d" % exception.code, error_type="context")
             return exception.code
 
         assert isinstance(exception, Exception)
-        output.error(traceback.format_exc())
+        output.error(traceback.format_exc(), error_type="context")
         msg = exception_message_safe(exception)
-        output.error(msg)
+        output.error(msg, error_type="context")
         return ERROR_UNEXPECTED
 
 

conan/internal/api/detect_api.py

@@ -5,6 +5,7 @@
 import textwrap
 
 from conan.api.output import ConanOutput
+from conans.errors import ConanException
 from conans.model.version import Version
 from conans.util.files import save
 from conans.util.runners import check_output_runner, detect_runner
@@ -205,6 +206,7 @@ def default_msvc_runtime(compiler):
 def default_cppstd(compiler, compiler_version):
     """ returns the default cppstd for the compiler-version. This is not detected, just the default
     """
+
     def _clang_cppstd_default(version):
         if version >= "16":
             return "gnu17"
@@ -264,18 +266,17 @@ def detect_compiler():
         if "gcc" in command or "g++" in command or "c++" in command:
             gcc, gcc_version = _gcc_compiler(command)
             if platform.system() == "Darwin" and gcc is None:
-                output.error("%s detected as a frontend using apple-clang. "
-                             "Compiler not supported" % command)
+                raise ConanException("%s detected as a frontend using apple-clang. "
+                                     "Compiler not supported" % command)
             return gcc, gcc_version
         if platform.system() == "SunOS" and command.lower() == "cc":
             return _sun_cc_compiler(command)
-        if platform.system() == "Windows" and command.rstrip('"').endswith(("cl", "cl.exe")) \
-                and "clang" not in command:
+        if (platform.system() == "Windows" and command.rstrip('"').endswith(("cl", "cl.exe"))
+            and "clang" not in command):
             return _msvc_cl_compiler(command)
 
         # I am not able to find its version
-        output.error("Not able to automatically detect '%s' version" % command)
-        return None, None
+        raise ConanException("Not able to automatically detect '%s' version" % command)
 
     if platform.system() == "Windows":
         version = _detect_vs_ide_version()

conan/internal/cache/db/cache_database.py

@@ -4,6 +4,7 @@
 from conan.api.output import ConanOutput
 from conan.internal.cache.db.packages_table import PackagesDBTable
 from conan.internal.cache.db.recipes_table import RecipesDBTable
+from conans.errors import ConanException
 from conans.model.package_ref import PkgReference
 from conans.model.recipe_ref import RecipeReference
 from conans.model.version import Version
@@ -13,8 +14,8 @@ class CacheDatabase:
 
     def __init__(self, filename):
         version = sqlite3.sqlite_version
-        if Version(version) < "3.7.11":  # Not an exception, in case some false positives
-            ConanOutput().error(f"Your sqlite3 '{version} < 3.7.11' version is not supported")
+        if Version(version) < "3.7.11":
+            raise ConanException(f"Your sqlite3 '{version} < 3.7.11' version is not supported")
         self._recipes = RecipesDBTable(filename)
         self._packages = PackagesDBTable(filename)
         if not os.path.isfile(filename):

conan/internal/conan_app.py

@@ -38,14 +38,14 @@ def __init__(self, requester, cmd_wrapper, global_conf, cache):
 
 class ConanApp(object):
     def __init__(self, cache_folder, global_conf):
-
+        self._configure(global_conf)
         self.cache_folder = cache_folder
         self.cache = ClientCache(self.cache_folder, global_conf)
 
         home_paths = HomePaths(self.cache_folder)
         self.hook_manager = HookManager(home_paths.hooks_path)
+
         # Wraps an http_requester to inject proxies, certs, etc
-        ConanOutput.define_silence_warnings(global_conf.get("core:skip_warnings", check_type=list))
         self.requester = ConanRequester(global_conf, cache_folder)
         # To handle remote connections
         rest_client_factory = RestApiClientFactory(self.requester, global_conf)
@@ -61,3 +61,9 @@ def __init__(self, cache_folder, global_conf):
         cmd_wrap = CmdWrapper(home_paths.wrapper_path)
         conanfile_helpers = ConanFileHelpers(self.requester, cmd_wrap, global_conf, self.cache)
         self.loader = ConanFileLoader(self.pyreq_loader, conanfile_helpers)
+
+    @staticmethod
+    def _configure(global_conf):
+        ConanOutput.set_warnings_as_errors(global_conf.get("core:warnings_as_errors",
+                                                           default=False, check_type=bool))
+        ConanOutput.define_silence_warnings(global_conf.get("core:skip_warnings", check_type=list))

conan/internal/deploy.py

@@ -77,7 +77,7 @@ def _deploy_single(dep, conanfile, output_folder, folder_name):
     except Exception as e:
         if "WinError 1314" in str(e):
             ConanOutput().error("full_deploy: Symlinks in Windows require admin privileges "
-                                "or 'Developer mode = ON'")
+                                "or 'Developer mode = ON'", error_type="context")
         raise ConanException(f"full_deploy: The copy of '{dep}' files failed: {e}.\nYou can "
                              f"use 'tools.deployer:symlinks' conf to disable symlinks")
     dep.set_deploy_folder(new_folder)

conan/internal/integrity_check.py

@@ -41,11 +41,11 @@ def _recipe_corrupted(self, ref: RecipeReference):
                                        if not k.startswith("export_source")}
 
         if read_manifest != expected_manifest:
-            output.error(f"{ref}: Manifest mismatch")
-            output.error(f"Folder: {layout.export()}")
+            output.error(f"{ref}: Manifest mismatch", error_type="context")
+            output.error(f"Folder: {layout.export()}", error_type="context")
             diff = read_manifest.difference(expected_manifest)
             for fname, (h1, h2) in diff.items():
-                output.error(f"    '{fname}' (manifest: {h1}, file: {h2})")
+                output.error(f"    '{fname}' (manifest: {h1}, file: {h2})", error_type="context")
             return True
         output.info(f"{ref}: Integrity checked: ok")
 
@@ -55,10 +55,10 @@ def _package_corrupted(self, ref: PkgReference):
         read_manifest, expected_manifest = layout.package_manifests()
 
         if read_manifest != expected_manifest:
-            output.error(f"{ref}: Manifest mismatch")
-            output.error(f"Folder: {layout.package()}")
+            output.error(f"{ref}: Manifest mismatch", error_type="context")
+            output.error(f"Folder: {layout.package()}", error_type="context")
             diff = read_manifest.difference(expected_manifest)
             for fname, (h1, h2) in diff.items():
-                output.error(f"    '{fname}' (manifest: {h1}, file: {h2})")
+                output.error(f"    '{fname}' (manifest: {h1}, file: {h2})", error_type="context")
             return True
         output.info(f"{ref}: Integrity checked: ok")

conan/tools/files/files.py

@@ -339,7 +339,7 @@ def print_progress(_, __):
                 try:
                     z.extract(file_, full_path)
                 except Exception as e:
-                    output.error("Error extract %s\n%s" % (file_.filename, str(e)))
+                    output.error(f"Error extract {file_.filename}\n{str(e)}", error_type="context")
         else:  # duplicated for, to avoid a platform check for each zipped file
             for file_ in zip_info:
                 extracted_size += file_.file_size
@@ -352,7 +352,7 @@ def print_progress(_, __):
                         perm = file_.external_attr >> 16 & 0xFFF
                         os.chmod(os.path.join(full_path, file_.filename), perm)
                 except Exception as e:
-                    output.error("Error extract %s\n%s" % (file_.filename, str(e)))
+                    output.error(f"Error extract {file_.filename}\n{str(e)}", error_type="context")
         output.writeln("")
 
 

conans/client/cmd/export.py

@@ -78,7 +78,7 @@ def cmd_export(app, global_conf, conanfile_path, name, version, user, channel, g
                 clean_dirty(source_folder)
         except BaseException as e:
             scoped_output.error("Unable to delete source folder. Will be marked as corrupted "
-                                "for deletion")
+                                "for deletion", error_type="context")
             scoped_output.warning(str(e))
             set_dirty(source_folder)
 

conans/client/downloaders/file_downloader.py

@@ -44,7 +44,7 @@ def download(self, url, file_path, retry=2, retry_wait=0, verify_ssl=True, auth=
                     if counter == retry:
                         raise
                     else:
-                        self._output.error(exc)
+                        self._output.warning(exc, warn_tag="network")
                         self._output.info(f"Waiting {retry_wait} seconds to retry...")
                         time.sleep(retry_wait)
 

conans/client/generators/__init__.py

@@ -95,7 +95,7 @@ def write_generators(conanfile, app):
                     continue
                 except Exception as e:
                     # When a generator fails, it is very useful to have the whole stacktrace
-                    conanfile.output.error(traceback.format_exc())
+                    conanfile.output.error(traceback.format_exc(), error_type="context")
                     raise ConanException(f"Error in generator '{generator_name}': {str(e)}") from e
     finally:
         # restore the generators attribute, so it can raise

conans/client/graph/build_mode.py

@@ -103,4 +103,4 @@ def should_build_missing(self, conanfile):
 
     def report_matches(self):
         for pattern in self._unused_patterns:
-            ConanOutput().error("No package matching '%s' pattern found." % pattern)
+            ConanOutput().error(f"No package matching '{pattern}' pattern found.", error_type="context")

conans/client/graph/install_graph.py

@@ -303,7 +303,7 @@ def _raise_missing(self, missing):
         missing_prefs_str = list(sorted([str(pref) for pref in missing_prefs]))
         out = ConanOutput()
         for pref_str in missing_prefs_str:
-            out.error("Missing binary: %s" % pref_str)
+            out.error(f"Missing binary: {pref_str}", error_type="context")
         out.writeln("")
 
         # Report details just the first one

conans/client/installer.py

@@ -97,7 +97,7 @@ def _build(self, conanfile, pref):
             conanfile.output.success("Package '%s' built" % pref.package_id)
             conanfile.output.info("Build folder %s" % conanfile.build_folder)
         except Exception as exc:
-            conanfile.output.error("\nPackage '%s' build failed" % pref.package_id)
+            conanfile.output.error(f"\nPackage '{pref.package_id}' build failed", error_type="context")
             conanfile.output.warning("Build folder %s" % conanfile.build_folder)
             if isinstance(exc, ConanException):
                 raise exc

conans/client/migrations.py

@@ -69,7 +69,8 @@ def _migrate_pkg_db_lru(cache_folder, old_version):
                                f"INTEGER DEFAULT '{lru}' NOT NULL;")
     except Exception:
         ConanOutput().error(f"Could not complete the 2.0.14 DB migration."
-                            " Please manually remove your .conan2 cache and reinstall packages")
+                            " Please manually remove your .conan2 cache and reinstall packages",
+                            error_type="context")
         raise
     else:  # generate the back-migration script
         undo_lru = textwrap.dedent("""\

conans/client/remote_manager.py

@@ -63,7 +63,7 @@ def get_recipe(self, ref, remote, metadata=None):
                                      f"no conanmanifest.txt")
             self._signer.verify(ref, download_export, files=zipped_files)
         except BaseException:  # So KeyboardInterrupt also cleans things
-            ConanOutput(scope=str(ref)).error(f"Error downloading from remote '{remote.name}'")
+            ConanOutput(scope=str(ref)).error(f"Error downloading from remote '{remote.name}'", error_type="context")
             self._cache.remove_recipe_layout(layout)
             raise
         export_folder = layout.export()
@@ -91,7 +91,7 @@ def get_recipe_metadata(self, ref, remote, metadata):
             self._call_remote(remote, "get_recipe", ref, download_export, metadata,
                               only_metadata=True)
         except BaseException:  # So KeyboardInterrupt also cleans things
-            output.error(f"Error downloading metadata from remote '{remote.name}'")
+            output.error(f"Error downloading metadata from remote '{remote.name}'", error_type="context")
             raise
 
     def get_recipe_sources(self, ref, layout, remote):
@@ -134,8 +134,8 @@ def get_package_metadata(self, pref, remote, metadata):
             self._call_remote(remote, "get_package", pref, download_pkg_folder,
                               metadata, only_metadata=True)
         except BaseException as e:  # So KeyboardInterrupt also cleans things
-            output.error("Exception while getting package metadata: %s" % str(pref.package_id))
-            output.error("Exception: %s %s" % (type(e), str(e)))
+            output.error(f"Exception while getting package metadata: {str(pref.package_id)}", error_type="context")
+            output.error(f"Exception: {type(e)} {str(e)}", error_type="context")
             raise
 
     def _get_package(self, layout, pref, remote, scoped_output, metadata):
@@ -166,8 +166,8 @@ def _get_package(self, layout, pref, remote, scoped_output, metadata):
             raise PackageNotFoundException(pref)
         except BaseException as e:  # So KeyboardInterrupt also cleans things
             self._cache.remove_package_layout(layout)
-            scoped_output.error("Exception while getting package: %s" % str(pref.package_id))
-            scoped_output.error("Exception: %s %s" % (type(e), str(e)))
+            scoped_output.error(f"Exception while getting package: {str(pref.package_id)}", error_type="context")
+            scoped_output.error(f"Exception: {type(e)} {str(e)}", error_type="context")
             raise
 
     def search_recipes(self, remote, pattern):

conans/client/rest/auth_manager.py

@@ -78,9 +78,9 @@ def _retry_with_new_token(self, user, remote, method_name, *args, **kwargs):
             except AuthenticationException:
                 out = ConanOutput()
                 if user is None:
-                    out.error('Wrong user or password')
+                    out.error('Wrong user or password', error_type="context")
                 else:
-                    out.error('Wrong password for user "%s"' % user)
+                    out.error(f'Wrong password for user "{user}"', error_type="context")
                     out.info('You can change username with "conan remote login <remote> <username>"')
             else:
                 return self.call_rest_api_method(remote, method_name, *args, **kwargs)
@@ -98,7 +98,7 @@ def _clear_user_tokens_in_db(self, user, remote):
             self._localdb.store(user, token=None, refresh_token=None, remote_url=remote.url)
         except Exception as e:
             out = ConanOutput()
-            out.error('Your credentials could not be stored in local cache\n')
+            out.error('Your credentials could not be stored in local cache\n', error_type="context")
             out.debug(str(e) + '\n')
 
     @staticmethod

conans/client/rest/file_uploader.py

@@ -76,7 +76,7 @@ def upload(self, url, abs_path, auth=None, dedup=False, retry=None, retry_wait=N
                     raise
                 else:
                     if self._output:
-                        self._output.error(exc)
+                        self._output.warning(exc, warn_tag="network")
                         self._output.info("Waiting %d seconds to retry..." % retry_wait)
                     time.sleep(retry_wait)
 

conans/client/rest/rest_client_v2.py

@@ -147,7 +147,7 @@ def _upload_files(self, files, urls):
             except (AuthenticationException, ForbiddenException):
                 raise
             except Exception as exc:
-                output.error("\nError uploading file: %s, '%s'" % (filename, exc))
+                output.error(f"\nError uploading file: {filename}, '{exc}'", error_type="context")
                 failed.append(filename)
 
         if failed:

conans/client/userio.py

@@ -129,5 +129,5 @@ def request_boolean(self, msg, default_option=None):
             elif s.lower() in ['no', 'n']:
                 ret = False
             else:
-                self._out.error("%s is not a valid answer" % s)
+                self._out.warning(f"{s} is not a valid answer")
         return ret