Validate that zowe.config.json file matches schema

src/core/zowe/core_for_zowe_sdk/config_file.py

@@ -69,6 +69,7 @@ class ConfigFile:
     4. Contents of the file.
     4.1 Profiles
     4.2 Defaults
+    4.3 Schema Property
     5. Secure Properties associated with the file.
     """
 
@@ -77,6 +78,7 @@ class ConfigFile:
     _location: Optional[str] = None
     profiles: Optional[dict] = None
     defaults: Optional[dict] = None
+    schema_property: Optional[dict] = None
     secure_props: Optional[dict] = None
     _missing_secure_props: list = field(default_factory=list)
 
@@ -100,6 +102,10 @@ def filepath(self) -> Optional[str]:
     @property
     def location(self) -> Optional[str]:
         return self._location
+
+    @property
+    def schema_path(self) -> Optional[str]:
+        return self.schema_property
 
     @location.setter
     def location(self, dirname: str) -> None:
@@ -120,6 +126,7 @@ def init_from_file(self) -> None:
             profile_jsonc = commentjson.load(fileobj)
 
         self.profiles = profile_jsonc.get("profiles", {})
+        self.schema_property = profile_jsonc.get("$schema", None)
         self.defaults = profile_jsonc.get("defaults", {})
 
         # loading secure props is done in load_profile_properties

src/core/zowe/core_for_zowe_sdk/profile_manager.py

@@ -12,9 +12,11 @@
 
 import os.path
 import warnings
+import jsonschema
 from typing import Optional
 
 from .config_file import ConfigFile, Profile
+from .validators import validate_config_json
 from .custom_warnings import (
     ConfigNotFoundWarning,
     ProfileNotFoundWarning,
@@ -169,12 +171,59 @@ def get_profile(
             )
         finally:
             return cfg_profile
+
+    @staticmethod
+    def validate_schema(
+        cfg: ConfigFile,
+        path_config_json: str,
+        opt_in: Optional[bool] = True,
+    ) -> str:
+        """
+        Get the $schema_property from the config and load the schema
+
+        Returns
+        -------
+        file_path to the $schema property
+        """
+
+        path_schema_json = None
+        try:
+            path_schema_json = cfg.schema_path
+            if path_schema_json is None:    # check if the $schema property is not defined
+                warnings.warn(
+                    f"$schema property could not found"
+                )
+
+            # validate the $schema property 
+            if path_schema_json and opt_in:
+                validate_config_json(path_config_json, path_schema_json)
+        except jsonschema.exceptions.ValidationError as exc:
+            raise jsonschema.exceptions.ValidationError(
+                f"Instance was invalid under the provided $schema property, {exc}"
+            )
+        except jsonschema.exceptions.SchemaError as exc:
+            raise jsonschema.exception.SchemaError(
+                f"The provided schema is invalid, {exc}"
+            )
+        except jsonschema.exceptions.UndefinedTypeCheck as exc:
+            raise jsonschema.exceptions.UndefinedTypeCheck(
+                f"A type checker was asked to check a type it did not have registered, {exc}"
+            )
+        except jsonschema.exceptions.UnknownType as exc:
+            raise jsonschema.exceptions.UnknownType(
+                f"Unknown type is found in {path_schema_json}, exc"
+            )
+        except jsonschema.exceptions.FormatError as exc:
+            raise jsonschema.exceptions.FormatError(
+                f"Validating a format {path_config_json} failed for {path_schema_json}, {exc}"
+            )
 
     def load(
         self,
         profile_name: Optional[str] = None,
         profile_type: Optional[str] = None,
         check_missing_props: bool = True,
+        opt_in: Optional[bool] = True,
     ) -> dict:
         """Load connection details from a team config profile.
         Returns
@@ -209,6 +258,7 @@ def load(
             "Global Config": self.global_config,
         }
         profile_props: dict = {}
+        schema_path = None
 
         missing_secure_props = []  # track which secure props were not loaded
 
@@ -224,6 +274,14 @@ def load(
                 )  # Define profile name that will be merged from other layers
             profile_props = {**profile_loaded.data, **profile_props}
 
+            # Validating $schema property for all the layers
+            if cfg._location and config_type in ("Project Config", "Global Config"):
+                path_config_json = cfg._location + "/zowe.config.json"
+                self.validate_schema(cfg, path_config_json, opt_in)
+            elif cfg._location and config_type in ("Project User Config", "Global User Config"):
+                path_config_json = cfg._location + "/zowe.config.user.json"
+                self.validate_schema(cfg, path_config_json, opt_in)
+
             missing_secure_props.extend(profile_loaded.missing_secure_props)
 
             if i == 1 and profile_props:

src/core/zowe/core_for_zowe_sdk/validators.py

@@ -12,6 +12,8 @@
 
 import commentjson
 from jsonschema import validate
+import os
+import requests
 
 
 def validate_config_json(path_config_json: str, path_schema_json: str):
@@ -31,10 +33,22 @@ def validate_config_json(path_config_json: str, path_schema_json: str):
         Provides details if config.json doesn't match schema.json, otherwise it returns None.
     """
 
+    # checks if the path_schema_json point to an internet URI and download the schema using the URI
+    if path_schema_json[:8] in ("https://", "http://"):
+        response = requests.get(path_schema_json)
+        schema_data = response.content.decode("utf-8")
+        schema_json = commentjson.load(schema_data)
+
+    # checks if the path_schema_json is a file
+    elif os.path.isfile(path_schema_json):
+        with open(path_schema_json) as file:
+            schema_json = commentjson.load(file)
+
+    # if there is no path_schema_json it will return None
+    else: 
+        return None
+
     with open(path_config_json) as file:
         config_json = commentjson.load(file)
 
-    with open(path_schema_json) as file:
-        schema_json = commentjson.load(file)
-
     return validate(instance=config_json, schema=schema_json)