[LYN-3463] Improve error message based on resource mapping manager loading status (#551)

Gems/AWSCore/Code/Include/Private/Configuration/AWSCoreConfiguration.h

@@ -25,13 +25,24 @@ namespace AWSCore
         : AWSCoreInternalRequestBus::Handler
     {
     public:
-        static constexpr const char AWSCORE_CONFIGURATION_FILENAME[] = "awscoreconfiguration.setreg";
+        static constexpr const char AWSCoreConfigurationName[] = "AWSCoreConfiguration";
+        static constexpr const char AWSCoreConfigurationFileName[] = "awscoreconfiguration.setreg";
 
-        static constexpr const char AWSCORE_RESOURCE_MAPPING_CONFIG_FOLDERNAME[] = "Config";
-        static constexpr const char AWSCORE_RESOURCE_MAPPING_CONFIG_FILENAME_KEY[] = "/AWSCore/ResourceMappingConfigFileName";
+        static constexpr const char AWSCoreResourceMappingConfigFolderName[] = "Config";
+        static constexpr const char AWSCoreResourceMappingConfigFileNameKey[] = "/AWSCore/ResourceMappingConfigFileName";
+
+        static constexpr const char AWSCoreDefaultProfileName[] = "default";
+        static constexpr const char AWSCoreProfileNameKey[] = "/AWSCore/ProfileName";
+
+        static constexpr const char ProjectSourceFolderNotFoundErrorMessage[] =
+            "Failed to get project source folder path.";
+        static constexpr const char ProfileNameNotFoundErrorMessage[] =
+            "Failed to get profile name, return default value instead.";
+        static constexpr const char ResourceMappingFileNameNotFoundErrorMessage[] =
+            "Failed to get resource mapping config file name, return empty value instead.";
+        static constexpr const char SettingsRegistryLoadFailureErrorMessage[] =
+            "Failed to load AWSCore settings registry file.";
 
-        static constexpr const char AWSCORE_DEFAULT_PROFILE_NAME[] = "default";
-        static constexpr const char AWSCORE_PROFILENAME_KEY[] = "/AWSCore/ProfileName";
 
         AWSCoreConfiguration();
         ~AWSCoreConfiguration() = default;
@@ -55,6 +66,9 @@ namespace AWSCore
         // Parse values from project .setreg file
         void ParseSettingsRegistryValues();
 
+        // Reset settings registry data
+        void ResetSettingsRegistryData();
+
         AZStd::string m_sourceProjectFolder;
         AZ::SettingsRegistryImpl m_settingsRegistry;
         AZStd::string m_profileName;

Gems/AWSCore/Code/Include/Private/ResourceMapping/AWSResourceMappingConstants.h

@@ -14,20 +14,20 @@
 
 namespace AWSCore
 {
-    static constexpr const char AWS_CHINA_REGION_PREFIX[] = "cn-";
+    static constexpr const char AWSChinaRegionPrefix[] = "cn-";
 
-    static constexpr const char AWS_FEATURE_GEM_RESTAPI_ID_KEYNAME_SUFFIX[] = ".RESTApiId";
-    static constexpr const char AWS_FEATURE_GEM_RESTAPI_STAGE_KEYNAME_SUFFIX[] = ".RESTApiStage";
+    static constexpr const char AWSFeatureGemRESTApiIdKeyNameSuffix[] = ".RESTApiId";
+    static constexpr const char AWSFeatureGemRESTApiStageKeyNameSuffix[] = ".RESTApiStage";
 
-    static constexpr const char RESOURCE_MAPPING_ACCOUNTID_KEYNAME[] = "AccountId";
-    static constexpr const char RESOURCE_MAPPING_RESOURCES_KEYNAME[] = "AWSResourceMappings";
-    static constexpr const char RESOURCE_MAPPING_NAMEID_KEYNAME[] = "Name/ID";
-    static constexpr const char RESOURCE_MAPPING_REGION_KEYNAME[] = "Region";
-    static constexpr const char RESOURCE_MAPPING_TYPE_KEYNAME[] = "Type";
-    static constexpr const char RESOURCE_MAPPING_VERSION_KEYNAME[] = "Version";
+    static constexpr const char ResourceMappingAccountIdKeyName[] = "AccountId";
+    static constexpr const char ResourceMappingResourcesKeyName[] = "AWSResourceMappings";
+    static constexpr const char ResourceMappingNameIdKeyName[] = "Name/ID";
+    static constexpr const char ResourceMappingRegionKeyName[] = "Region";
+    static constexpr const char ResourceMappingTypeKeyName[] = "Type";
+    static constexpr const char ResourceMappingVersionKeyName[] = "Version";
 
     // TODO: move this into an independent file under AWSCore gem, if resource mapping tool can reuse it
-    static constexpr const char RESOURCE_MAPPING_JSON_SCHEMA[] =
+    static constexpr const char ResourceMappingJsonSchema[] =
         R"({
     "$schema": "http://json-schema.org/draft-04/schema",
     "type": "object",

Gems/AWSCore/Code/Include/Private/ResourceMapping/AWSResourceMappingManager.h

@@ -45,6 +45,35 @@ namespace AWSCore
         };
 
     public:
+        static constexpr const char AWSResourceMappingManagerName[] = "AWSResourceMappingManager";
+        static constexpr const char ManagerUnexpectedStatusErrorMessage[] =
+            "AWSResourceMappingManager is in unexpected status.";
+        static constexpr const char ResourceMappingFileInvalidPathErrorMessage[] =
+            "Failed to get resource mapping config file path.";
+        static constexpr const char ResourceMappingKeyNotFoundErrorMessage[] =
+            "Failed to find resource mapping key: %s";
+        static constexpr const char ResourceMappingFileNotLoadedErrorMessage[] =
+            "Resource mapping config file is not loaded, please confirm %s is setup correctly.";
+        static constexpr const char ResourceMappingFileLoadFailureErrorMessage[] =
+            "Resource mapping config file failed to load, please confirm file is present and in correct format.";
+        static constexpr const char ResourceMappingRESTApiIdAndStageInconsistentErrorMessage[] =
+            "Resource mapping %s and %s have inconsistent region value, return empty service url.";
+        static constexpr const char ResourceMappingRESTApiInvalidServiceUrlErrorMessage[] =
+            "Unable to format REST Api url with RESTApiId=%s, RESTApiRegion=%s, RESTApiStage=%s, return empty service url.";
+        static constexpr const char ResourceMappingFileInvalidJsonFormatErrorMessage[] =
+            "Failed to read resource mapping config file: %s";
+        static constexpr const char ResourceMappingFileInvalidSchemaErrorMessage[] =
+            "Failed to load resource mapping config file json schema.";
+        static constexpr const char ResourceMappingFileInvalidContentErrorMessage[] =
+            "Failed to parse resource mapping config file: %s";
+
+        enum class Status : AZ::u8
+        {
+            NotLoaded = 0,
+            Ready = 1,
+            Error = 2
+        };
+
         AWSResourceMappingManager();
         ~AWSResourceMappingManager() = default;
 
@@ -63,7 +92,12 @@ namespace AWSCore
             const AZStd::string& restApiIdKeyName, const AZStd::string& restApiStageKeyName) const override;
         void ReloadConfigFile(bool reloadConfigFileName = false) override;
 
+        Status GetStatus() const;
+
     private:
+        // Get resource attribute error message based on the status
+        AZStd::string GetResourceAttributeErrorMessageByStatus(const AZStd::string& resourceKeyName) const;
+
         // Get resource attribute from resource mappings
         AZStd::string GetResourceAttribute(
             AZStd::function<AZStd::string(const AWSResourceMappingAttributes&)> getAttributeFunction,
@@ -83,6 +117,7 @@ namespace AWSCore
         // Validate JSON document against schema
         bool ValidateJsonDocumentAgainstSchema(const rapidjson::Document& jsonDocument);
 
+        Status m_status;
         // Resource mapping related data
         AZStd::string m_defaultAccountId;
         AZStd::string m_defaultRegion;

Gems/AWSCore/Code/Source/Configuration/AWSCoreConfiguration.cpp

@@ -20,7 +20,7 @@ namespace AWSCore
 {
     AWSCoreConfiguration::AWSCoreConfiguration()
         : m_sourceProjectFolder("")
-        , m_profileName(AWSCORE_DEFAULT_PROFILE_NAME)
+        , m_profileName(AWSCoreDefaultProfileName)
         , m_resourceMappingConfigFileName("")
     {
     }
@@ -44,16 +44,16 @@ namespace AWSCore
     {
         if (m_sourceProjectFolder.empty())
         {
-            AZ_Warning("AWSCoreConfiguration", false, "Failed to get source project folder path.");
+            AZ_Warning(AWSCoreConfigurationName, false, ProjectSourceFolderNotFoundErrorMessage);
             return "";
         }
         if (m_resourceMappingConfigFileName.empty())
         {
-            AZ_Warning("AWSCoreConfiguration", false, "Failed to get resource mapping config file name.");
+            AZ_Warning(AWSCoreConfigurationName, false, ResourceMappingFileNameNotFoundErrorMessage);
             return "";
         }
         AZStd::string configFilePath = AZStd::string::format("%s/%s/%s",
-            m_sourceProjectFolder.c_str(), AWSCORE_RESOURCE_MAPPING_CONFIG_FOLDERNAME, m_resourceMappingConfigFileName.c_str());
+            m_sourceProjectFolder.c_str(), AWSCoreResourceMappingConfigFolderName, m_resourceMappingConfigFileName.c_str());
         AzFramework::StringFunc::Path::Normalize(configFilePath);
         return configFilePath;
     }
@@ -68,17 +68,17 @@ namespace AWSCore
     {
         if (m_sourceProjectFolder.empty())
         {
-            AZ_Warning("AWSCoreConfiguration", false, "Failed to get source project folder path.");
+            AZ_Warning(AWSCoreConfigurationName, false, ProjectSourceFolderNotFoundErrorMessage);
             return;
         }
 
         AZStd::string settingsRegistryPath = AZStd::string::format("%s/%s/%s",
-            m_sourceProjectFolder.c_str(), AZ::SettingsRegistryInterface::RegistryFolder, AWSCoreConfiguration::AWSCORE_CONFIGURATION_FILENAME);
+            m_sourceProjectFolder.c_str(), AZ::SettingsRegistryInterface::RegistryFolder, AWSCoreConfiguration::AWSCoreConfigurationFileName);
         AzFramework::StringFunc::Path::Normalize(settingsRegistryPath);
 
         if (!m_settingsRegistry.MergeSettingsFile(settingsRegistryPath, AZ::SettingsRegistryInterface::Format::JsonMergePatch, ""))
         {
-            AZ_Warning("AWSCoreConfiguration", false, "Failed to merge AWS core settings registry.");
+            AZ_Warning(AWSCoreConfigurationName, false, SettingsRegistryLoadFailureErrorMessage);
             return;
         }
 
@@ -90,7 +90,7 @@ namespace AWSCore
         auto sourceProjectFolder = AZ::IO::FileIOBase::GetInstance()->GetAlias("@devassets@");
         if (!sourceProjectFolder)
         {
-            AZ_Error("AWSCoreConfiguration", false, "Failed to initialize source project folder path.");
+            AZ_Error(AWSCoreConfigurationName, false, ProjectSourceFolderNotFoundErrorMessage);
         }
         else
         {
@@ -102,24 +102,38 @@ namespace AWSCore
     {
         m_resourceMappingConfigFileName.clear();
         auto resourceMappingConfigFileNamePath = AZStd::string::format("%s%s",
-            AZ::SettingsRegistryMergeUtils::OrganizationRootKey, AWSCORE_RESOURCE_MAPPING_CONFIG_FILENAME_KEY);
+            AZ::SettingsRegistryMergeUtils::OrganizationRootKey, AWSCoreResourceMappingConfigFileNameKey);
         if (!m_settingsRegistry.Get(m_resourceMappingConfigFileName, resourceMappingConfigFileNamePath))
         {
-            AZ_Warning("AWSCoreConfiguration", false, "Failed to get resource mapping config file name from settings registry.");
+            AZ_Warning(AWSCoreConfigurationName, false, ResourceMappingFileNameNotFoundErrorMessage);
         }
 
         m_profileName.clear();
         auto profileNamePath = AZStd::string::format(
-            "%s%s", AZ::SettingsRegistryMergeUtils::OrganizationRootKey, AWSCORE_PROFILENAME_KEY);
+            "%s%s", AZ::SettingsRegistryMergeUtils::OrganizationRootKey, AWSCoreProfileNameKey);
         if (!m_settingsRegistry.Get(m_profileName, profileNamePath))
         {
-            AZ_Warning("AWSCoreConfiguration", false, "Failed to get profile name from settings registry, using default value instead.");
-            m_profileName = AWSCORE_DEFAULT_PROFILE_NAME;
+            AZ_Warning(AWSCoreConfigurationName, false, ProfileNameNotFoundErrorMessage);
+            m_profileName = AWSCoreDefaultProfileName;
         }
     }
 
+    void AWSCoreConfiguration::ResetSettingsRegistryData()
+    {
+        auto profileNamePath = AZStd::string::format("%s%s",
+            AZ::SettingsRegistryMergeUtils::OrganizationRootKey, AWSCoreProfileNameKey);
+        m_settingsRegistry.Remove(profileNamePath);
+        m_profileName.clear();
+
+        auto resourceMappingConfigFileNamePath = AZStd::string::format("%s%s",
+            AZ::SettingsRegistryMergeUtils::OrganizationRootKey, AWSCoreResourceMappingConfigFileNameKey);
+        m_settingsRegistry.Remove(resourceMappingConfigFileNamePath);
+        m_resourceMappingConfigFileName.clear();
+    }
+
     void AWSCoreConfiguration::ReloadConfiguration()
     {
+        ResetSettingsRegistryData();
         InitSettingsRegistry();
     }
 } // namespace AWSCore

Gems/AWSCore/Code/Source/Credential/AWSDefaultCredentialHandler.cpp

@@ -84,7 +84,7 @@ namespace AWSCore
         {
             AZ_Warning("AWSDefaultCredentialHandler", false, "Failed to get profile name, use default profile name instead");
             SetProfileCredentialsProvider(Aws::MakeShared<Aws::Auth::ProfileConfigFileAWSCredentialsProvider>(
-                AWSDEFAULTCREDENTIALHANDLER_ALLOC_TAG, AWSCoreConfiguration::AWSCORE_DEFAULT_PROFILE_NAME));
+                AWSDEFAULTCREDENTIALHANDLER_ALLOC_TAG, AWSCoreConfiguration::AWSCoreDefaultProfileName));
         }
         else
         {

Gems/AWSCore/Code/Source/ResourceMapping/AWSResourceMappingManager.cpp

@@ -12,12 +12,14 @@
 
 #include <AzCore/IO/Path/Path.h>
 #include <AzCore/JSON/schema.h>
+#include <AzCore/JSON/prettywriter.h>
 #include <AzCore/Settings/SettingsRegistry.h>
 #include <AzCore/Settings/SettingsRegistryImpl.h>
 #include <AzFramework/FileFunc/FileFunc.h>
 #include <AzFramework/StringFunc/StringFunc.h>
 
 #include <AWSCoreInternalBus.h>
+#include <Configuration/AWSCoreConfiguration.h>
 #include <ResourceMapping/AWSResourceMappingConstants.h>
 #include <ResourceMapping/AWSResourceMappingManager.h>
 #include <ResourceMapping/AWSResourceMappingUtils.h>
@@ -25,7 +27,8 @@
 namespace AWSCore
 {
     AWSResourceMappingManager::AWSResourceMappingManager()
-        : m_defaultAccountId("")
+        : m_status(Status::NotLoaded)
+        , m_defaultAccountId("")
         , m_defaultRegion("")
         , m_resourceMappings()
     {
@@ -43,11 +46,27 @@ namespace AWSCore
         ResetResourceMappingsData();
     }
 
+    AZStd::string AWSResourceMappingManager::GetResourceAttributeErrorMessageByStatus(const AZStd::string& resourceKeyName) const
+    {
+        switch (m_status)
+        {
+        case Status::NotLoaded:
+            return AZStd::string::format(ResourceMappingFileNotLoadedErrorMessage, AWSCoreConfiguration::AWSCoreConfigurationFileName);
+        case Status::Ready:
+            return AZStd::string::format(ResourceMappingKeyNotFoundErrorMessage, resourceKeyName.c_str());
+        case Status::Error:
+            return ResourceMappingFileLoadFailureErrorMessage;
+        default:
+            return ManagerUnexpectedStatusErrorMessage;
+        }
+    }
+
     AZStd::string AWSResourceMappingManager::GetDefaultAccountId() const
     {
         if (m_defaultAccountId.empty())
         {
-            AZ_Warning("AWSResourceMappingManager", false, "Account Id should not be empty, please make sure config file is valid.");
+            AZ_Warning(AWSResourceMappingManagerName, false,
+                GetResourceAttributeErrorMessageByStatus(ResourceMappingAccountIdKeyName).c_str());
         }
         return m_defaultAccountId;
     }
@@ -56,7 +75,8 @@ namespace AWSCore
     {
         if (m_defaultRegion.empty())
         {
-            AZ_Warning("AWSResourceMappingManager", false, "Region should not be empty, please make sure config file is valid.");
+            AZ_Warning(AWSResourceMappingManagerName, false,
+                GetResourceAttributeErrorMessageByStatus(ResourceMappingRegionKeyName).c_str());
         }
         return m_defaultRegion;
     }
@@ -100,8 +120,8 @@ namespace AWSCore
     AZStd::string AWSResourceMappingManager::GetServiceUrlByServiceName(const AZStd::string& serviceName) const
     {
         return GetServiceUrlByRESTApiIdAndStage(
-            AZStd::string::format("%s%s", serviceName.c_str(), AWS_FEATURE_GEM_RESTAPI_ID_KEYNAME_SUFFIX),
-            AZStd::string::format("%s%s", serviceName.c_str(), AWS_FEATURE_GEM_RESTAPI_STAGE_KEYNAME_SUFFIX));
+            AZStd::string::format("%s%s", serviceName.c_str(), AWSFeatureGemRESTApiIdKeyNameSuffix),
+            AZStd::string::format("%s%s", serviceName.c_str(), AWSFeatureGemRESTApiStageKeyNameSuffix));
     }
 
     AZStd::string AWSResourceMappingManager::GetServiceUrlByRESTApiIdAndStage(
@@ -113,16 +133,13 @@ namespace AWSCore
         AZStd::string serviceRegion = GetResourceRegion(restApiIdKeyName);
         if (serviceRegion != GetResourceRegion(restApiStageKeyName))
         {
-            AZ_Warning(
-                "AWSResourceMappingManager", false, "%s and %s have inconsistent region value, return empty service url.",
+            AZ_Warning(AWSResourceMappingManagerName, false, ResourceMappingRESTApiIdAndStageInconsistentErrorMessage,
                 restApiIdKeyName.c_str(), restApiStageKeyName.c_str());
             return "";
         }
 
         AZStd::string serviceRESTApiUrl = AWSResourceMappingUtils::FormatRESTApiUrl(serviceRESTApiId, serviceRegion, serviceRESTApiStage);
-        AZ_Warning(
-            "AWSResourceMappingManager", !serviceRESTApiUrl.empty(),
-            "Unable to format REST Api url with RESTApiId=%s, RESTApiRegion=%s, RESTApiStage=%s, return empty service url.",
+        AZ_Warning(AWSResourceMappingManagerName, !serviceRESTApiUrl.empty(), ResourceMappingRESTApiInvalidServiceUrlErrorMessage,
             serviceRESTApiId.c_str(), serviceRegion.c_str(), serviceRESTApiStage.c_str());
         return serviceRESTApiUrl;
     }
@@ -136,16 +153,21 @@ namespace AWSCore
             return getAttributeFunction(iter->second);
         }
 
-        AZ_Warning("AWSResourceMappingManager", false, "Failed to find resource mapping key: %s.", resourceKeyName.c_str());
+        AZ_Warning(AWSResourceMappingManagerName, false, GetResourceAttributeErrorMessageByStatus(resourceKeyName).c_str());
         return "";
     }
 
+    AWSResourceMappingManager::Status AWSResourceMappingManager::GetStatus() const
+    {
+        return m_status;
+    }
+
     void AWSResourceMappingManager::ParseJsonDocument(const rapidjson::Document& jsonDocument)
     {
-        m_defaultAccountId = jsonDocument.FindMember(RESOURCE_MAPPING_ACCOUNTID_KEYNAME)->value.GetString();
-        m_defaultRegion = jsonDocument.FindMember(RESOURCE_MAPPING_REGION_KEYNAME)->value.GetString();
+        m_defaultAccountId = jsonDocument.FindMember(ResourceMappingAccountIdKeyName)->value.GetString();
+        m_defaultRegion = jsonDocument.FindMember(ResourceMappingRegionKeyName)->value.GetString();
 
-        auto resourceMappings = jsonDocument.FindMember(RESOURCE_MAPPING_RESOURCES_KEYNAME)->value.GetObject();
+        auto resourceMappings = jsonDocument.FindMember(ResourceMappingResourcesKeyName)->value.GetObject();
         for (auto mappingIter = resourceMappings.MemberBegin(); mappingIter != resourceMappings.MemberEnd(); mappingIter++)
         {
             auto mappingValue = mappingIter->value.GetObject();
@@ -162,16 +184,16 @@ namespace AWSCore
         const JsonObject& jsonObject)
     {
         AWSResourceMappingAttributes attributes;
-        if (jsonObject.HasMember(RESOURCE_MAPPING_ACCOUNTID_KEYNAME))
+        if (jsonObject.HasMember(ResourceMappingAccountIdKeyName))
         {
-            attributes.resourceAccountId = jsonObject.FindMember(RESOURCE_MAPPING_ACCOUNTID_KEYNAME)->value.GetString();
+            attributes.resourceAccountId = jsonObject.FindMember(ResourceMappingAccountIdKeyName)->value.GetString();
         }
-        attributes.resourceNameId = jsonObject.FindMember(RESOURCE_MAPPING_NAMEID_KEYNAME)->value.GetString();
-        if (jsonObject.HasMember(RESOURCE_MAPPING_REGION_KEYNAME))
+        attributes.resourceNameId = jsonObject.FindMember(ResourceMappingNameIdKeyName)->value.GetString();
+        if (jsonObject.HasMember(ResourceMappingRegionKeyName))
         {
-            attributes.resourceRegion = jsonObject.FindMember(RESOURCE_MAPPING_REGION_KEYNAME)->value.GetString();
+            attributes.resourceRegion = jsonObject.FindMember(ResourceMappingRegionKeyName)->value.GetString();
         }
-        attributes.resourceType = jsonObject.FindMember(RESOURCE_MAPPING_TYPE_KEYNAME)->value.GetString();
+        attributes.resourceType = jsonObject.FindMember(ResourceMappingTypeKeyName)->value.GetString();
         return attributes;
     }
 
@@ -188,7 +210,7 @@ namespace AWSCore
         AWSCoreInternalRequestBus::BroadcastResult(configJsonPath, &AWSCoreInternalRequests::GetResourceMappingConfigFilePath);
         if (configJsonPath.empty())
         {
-            AZ_Warning("AWSResourceMappingManager", false, "Failed to get resource mapping config file path.");
+            AZ_Warning(AWSResourceMappingManagerName, false, ResourceMappingFileInvalidPathErrorMessage);
             return;
         }
 
@@ -201,20 +223,26 @@ namespace AWSCore
             if (!ValidateJsonDocumentAgainstSchema(jsonDocument))
             {
                 // Failed to satisfy the validation against json schema
+                m_status = Status::Error;
                 return;
             }
             ParseJsonDocument(jsonDocument);
         }
         else
         {
-            AZ_Warning(
-                "AWSResourceMappingManager", false, "Failed to get read resource mapping config file: %s\n Error: %s",
-                configJsonPath.c_str(), readJsonOutcome.GetError().c_str());
+            m_status = Status::Error;
+            AZ_Warning(AWSResourceMappingManagerName, false,
+                ResourceMappingFileInvalidJsonFormatErrorMessage, readJsonOutcome.GetError().c_str());
+            return;
         }
+
+        // Resource mapping config file gets loaded successfully
+        m_status = Status::Ready;
     }
 
     void AWSResourceMappingManager::ResetResourceMappingsData()
     {
+        m_status = Status::NotLoaded;
         m_defaultAccountId = "";
         m_defaultRegion = "";
         m_resourceMappings.clear();
@@ -223,9 +251,9 @@ namespace AWSCore
     bool AWSResourceMappingManager::ValidateJsonDocumentAgainstSchema(const rapidjson::Document& jsonDocument)
     {
         rapidjson::Document jsonSchemaDocument;
-        if (jsonSchemaDocument.Parse(RESOURCE_MAPPING_JSON_SCHEMA).HasParseError())
+        if (jsonSchemaDocument.Parse(ResourceMappingJsonSchema).HasParseError())
         {
-            AZ_Error("AWSResourceMappingManager", false, "Invalid resource mapping json schema.");
+            AZ_Error(AWSResourceMappingManagerName, false, ResourceMappingFileInvalidSchemaErrorMessage);
             return false;
         }
 
@@ -235,12 +263,10 @@ namespace AWSCore
         if (!jsonDocument.Accept(validator))
         {
             rapidjson::StringBuffer error;
-            validator.GetInvalidSchemaPointer().StringifyUriFragment(error);
-            AZ_Warning("AWSResourceMappingManager", false, "Failed to load config file, invalid schema: %s.", error.GetString());
-            AZ_Warning("AWSResourceMappingManager", false, "Failed to load config file, invalid keyword: %s.", validator.GetInvalidSchemaKeyword());
-            error.Clear();
-            validator.GetInvalidDocumentPointer().StringifyUriFragment(error);
-            AZ_Warning("AWSResourceMappingManager", false, "Failed to load config file, invalid document: %s.", error.GetString());
+            rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(error);
+            validator.GetError().Accept(writer);
+            AZ_Warning(AWSResourceMappingManagerName, false, ResourceMappingFileInvalidContentErrorMessage, error.GetString());
+
             return false;
         }
         return true;

Gems/AWSCore/Code/Source/ResourceMapping/AWSResourceMappingUtils.cpp

@@ -18,8 +18,8 @@ namespace AWSCore
     namespace AWSResourceMappingUtils
     {
         // https://docs.aws.amazon.com/general/latest/gr/apigateway.html
-        static constexpr char RESTAPI_URL_FORMAT[] = "https://%s.execute-api.%s.amazonaws.com/%s";
-        static constexpr char RESTAPI_CHINA_URL_FORMAT[] = "https://%s.execute-api.%s.amazonaws.com.cn/%s";
+        static constexpr char RESTApiUrlFormat[] = "https://%s.execute-api.%s.amazonaws.com/%s";
+        static constexpr char RESTApiChinaUrlFormat[] = "https://%s.execute-api.%s.amazonaws.com.cn/%s";
 
         AZStd::string FormatRESTApiUrl(
             const AZStd::string& restApiId, const AZStd::string& restApiRegion, const AZStd::string& restApiStage)
@@ -27,14 +27,14 @@ namespace AWSCore
             // https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-call-api.html
             if (!restApiId.empty() && !restApiRegion.empty() && !restApiStage.empty())
             {
-                if (restApiRegion.rfind(AWS_CHINA_REGION_PREFIX, 0) == 0)
+                if (restApiRegion.rfind(AWSChinaRegionPrefix, 0) == 0)
                 {
-                    return AZStd::string::format(RESTAPI_CHINA_URL_FORMAT,
+                    return AZStd::string::format(RESTApiChinaUrlFormat,
                         restApiId.c_str(), restApiRegion.c_str(), restApiStage.c_str());
                 }
                 else
                 {
-                    return AZStd::string::format(RESTAPI_URL_FORMAT,
+                    return AZStd::string::format(RESTApiUrlFormat,
                         restApiId.c_str(), restApiRegion.c_str(), restApiStage.c_str());
                 }
             }

Gems/AWSCore/Code/Tests/Configuration/AWSCoreConfigurationTest.cpp

@@ -46,7 +46,7 @@ public:
     void CreateTestSetRegFile(const AZStd::string& setregContent)
     {
         m_normalizedSetRegFilePath = AZStd::string::format("%s/%s",
-            m_normalizedSetRegFolderPath.c_str(), AWSCore::AWSCoreConfiguration::AWSCORE_CONFIGURATION_FILENAME);
+            m_normalizedSetRegFolderPath.c_str(), AWSCore::AWSCoreConfiguration::AWSCoreConfigurationFileName);
         AzFramework::StringFunc::Path::Normalize(m_normalizedSetRegFilePath);
         CreateTestFile(m_normalizedSetRegFilePath, setregContent);
     }
@@ -177,7 +177,7 @@ TEST_F(AWSCoreConfigurationTest, ReloadConfiguration_LoadValidSettingsRegistryAf
     auto actualConfigFilePath = m_awsCoreConfiguration->GetResourceMappingConfigFilePath();
     auto actualProfileName = m_awsCoreConfiguration->GetProfileName();
     EXPECT_TRUE(actualConfigFilePath.empty());
-    EXPECT_TRUE(actualProfileName == AWSCoreConfiguration::AWSCORE_DEFAULT_PROFILE_NAME);
+    EXPECT_TRUE(actualProfileName == AWSCoreConfiguration::AWSCoreDefaultProfileName);
 
     CreateTestSetRegFile(TEST_VALID_RESOURCE_MAPPING_SETREG);
     m_awsCoreConfiguration->ReloadConfiguration();
@@ -185,5 +185,24 @@ TEST_F(AWSCoreConfigurationTest, ReloadConfiguration_LoadValidSettingsRegistryAf
     actualConfigFilePath = m_awsCoreConfiguration->GetResourceMappingConfigFilePath();
     actualProfileName = m_awsCoreConfiguration->GetProfileName();
     EXPECT_FALSE(actualConfigFilePath.empty());
-    EXPECT_TRUE(actualProfileName != AWSCoreConfiguration::AWSCORE_DEFAULT_PROFILE_NAME);
+    EXPECT_TRUE(actualProfileName != AWSCoreConfiguration::AWSCoreDefaultProfileName);
+}
+
+TEST_F(AWSCoreConfigurationTest, ReloadConfiguration_LoadInvalidSettingsRegistryAfterValidOne_ReturnEmptyConfigFilePath)
+{
+    CreateTestSetRegFile(TEST_VALID_RESOURCE_MAPPING_SETREG);
+    m_awsCoreConfiguration->InitConfig();
+
+    auto actualConfigFilePath = m_awsCoreConfiguration->GetResourceMappingConfigFilePath();
+    auto actualProfileName = m_awsCoreConfiguration->GetProfileName();
+    EXPECT_FALSE(actualConfigFilePath.empty());
+    EXPECT_TRUE(actualProfileName != AWSCoreConfiguration::AWSCoreDefaultProfileName);
+
+    CreateTestSetRegFile(TEST_INVALID_RESOURCE_MAPPING_SETREG);
+    m_awsCoreConfiguration->ReloadConfiguration();
+
+    actualConfigFilePath = m_awsCoreConfiguration->GetResourceMappingConfigFilePath();
+    actualProfileName = m_awsCoreConfiguration->GetProfileName();
+    EXPECT_TRUE(actualConfigFilePath.empty());
+    EXPECT_TRUE(actualProfileName == AWSCoreConfiguration::AWSCoreDefaultProfileName);
 }

Gems/AWSCore/Code/Tests/ResourceMapping/AWSResourceMappingManagerTest.cpp

@@ -98,7 +98,7 @@ public:
             "AWSResourceMappingManager", AZ::Uuid::CreateRandom().ToString<AZStd::string>(false, false).c_str());
         AzFramework::StringFunc::Path::Normalize(m_normalizedSourceProjectFolder);
         m_normalizedConfigFolderPath = AZStd::string::format("%s/%s/",
-            m_normalizedSourceProjectFolder.c_str(), AWSCore::AWSCoreConfiguration::AWSCORE_RESOURCE_MAPPING_CONFIG_FOLDERNAME);
+            m_normalizedSourceProjectFolder.c_str(), AWSCore::AWSCoreConfiguration::AWSCoreResourceMappingConfigFolderName);
         AzFramework::StringFunc::Path::Normalize(m_normalizedConfigFolderPath);
         AWSCoreInternalRequestBus::Handler::BusConnect();
     }
@@ -178,6 +178,7 @@ TEST_F(AWSResourceMappingManagerTest, ActivateManager_ParseInvalidConfigFile_Con
     EXPECT_EQ(m_reloadConfigurationCounter, 1);
     EXPECT_TRUE(actualAccountId.empty());
     EXPECT_TRUE(actualRegion.empty());
+    EXPECT_TRUE(m_resourceMappingManager->GetStatus() == AWSResourceMappingManager::Status::Error);
 }
 
 TEST_F(AWSResourceMappingManagerTest, ActivateManager_ParseValidConfigFile_ConfigDataIsNotEmpty)
@@ -192,6 +193,7 @@ TEST_F(AWSResourceMappingManagerTest, ActivateManager_ParseValidConfigFile_Confi
     EXPECT_EQ(m_reloadConfigurationCounter, 1);
     EXPECT_FALSE(actualAccountId.empty());
     EXPECT_FALSE(actualRegion.empty());
+    EXPECT_TRUE(m_resourceMappingManager->GetStatus() == AWSResourceMappingManager::Status::Ready);
 }
 
 TEST_F(AWSResourceMappingManagerTest, ActivateManager_ParseValidConfigFile_ConfigDataIsNotEmptyWithMultithreadCalls)
@@ -230,11 +232,13 @@ TEST_F(AWSResourceMappingManagerTest, DeactivateManager_AfterActivatingWithValid
     AWSResourceMappingRequestBus::BroadcastResult(actualRegion, &AWSResourceMappingRequests::GetDefaultRegion);
     EXPECT_FALSE(actualAccountId.empty());
     EXPECT_FALSE(actualRegion.empty());
+    EXPECT_TRUE(m_resourceMappingManager->GetStatus() == AWSResourceMappingManager::Status::Ready);
 
     m_resourceMappingManager->DeactivateManager();
 
     EXPECT_TRUE(m_resourceMappingManager->GetDefaultAccountId().empty());
     EXPECT_TRUE(m_resourceMappingManager->GetDefaultRegion().empty());
+    EXPECT_TRUE(m_resourceMappingManager->GetStatus() == AWSResourceMappingManager::Status::NotLoaded);
 }
 
 TEST_F(AWSResourceMappingManagerTest, GetDefaultAccountId_AfterParsingValidConfigFile_GetExpectedDefaultAccountId)
@@ -416,6 +420,7 @@ TEST_F(AWSResourceMappingManagerTest, ReloadConfigFile_ParseValidConfigFileAfter
     EXPECT_EQ(m_reloadConfigurationCounter, 1);
     EXPECT_TRUE(actualAccountId.empty());
     EXPECT_TRUE(actualRegion.empty());
+    EXPECT_TRUE(m_resourceMappingManager->GetStatus() == AWSResourceMappingManager::Status::Error);
 
     CreateTestConfigFile(TEST_VALID_RESOURCE_MAPPING_CONFIG_FILE);
     m_resourceMappingManager->ReloadConfigFile();
@@ -425,6 +430,7 @@ TEST_F(AWSResourceMappingManagerTest, ReloadConfigFile_ParseValidConfigFileAfter
     EXPECT_EQ(m_reloadConfigurationCounter, 1);
     EXPECT_FALSE(actualAccountId.empty());
     EXPECT_FALSE(actualRegion.empty());
+    EXPECT_TRUE(m_resourceMappingManager->GetStatus() == AWSResourceMappingManager::Status::Ready);
 }
 
 TEST_F(AWSResourceMappingManagerTest, ReloadConfigFile_ReloadConfigFileNameAndParseValidConfigFile_ConfigDataGetParsed)
@@ -435,6 +441,7 @@ TEST_F(AWSResourceMappingManagerTest, ReloadConfigFile_ReloadConfigFileNameAndPa
     EXPECT_EQ(m_reloadConfigurationCounter, 1);
     EXPECT_FALSE(m_resourceMappingManager->GetDefaultAccountId().empty());
     EXPECT_FALSE(m_resourceMappingManager->GetDefaultRegion().empty());
+    EXPECT_TRUE(m_resourceMappingManager->GetStatus() == AWSResourceMappingManager::Status::Ready);
 }
 
 TEST_F(AWSResourceMappingManagerTest, ReloadConfigFile_MissingSetRegFile_ConfigDataIsNotParsed)
@@ -444,4 +451,5 @@ TEST_F(AWSResourceMappingManagerTest, ReloadConfigFile_MissingSetRegFile_ConfigD
     EXPECT_EQ(m_reloadConfigurationCounter, 1);
     EXPECT_TRUE(m_resourceMappingManager->GetDefaultAccountId().empty());
     EXPECT_TRUE(m_resourceMappingManager->GetDefaultRegion().empty());
+    EXPECT_TRUE(m_resourceMappingManager->GetStatus() == AWSResourceMappingManager::Status::NotLoaded);
 }