Validate PM Dictionary and VES Events YAML Files

Validate, during the package onboarding, YAML files declared in the
manifest as type onap_ves_events or onap_pm_dictionary under
non_mano_artifact_sets. Check if the file is not empty, if has a yaml
extension and if it has a valid yaml content.

Change-Id: I260d0f5355e9e77b6499f553f8aa9f7e6d0693da
Issue-ID: SDC-2475
Signed-off-by: andre.schmid <andre.schmid@est.tech>

2 files changed, 198 insertions, 107 deletions

diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/csar/validation/NonManoArtifactType.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/csar/validation/NonManoArtifactType.java
new file mode 100644
index 0000000000..53ffb0b608
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/csar/validation/NonManoArtifactType.java
@@ -0,0 +1,42 @@
+/*
+ * ============LICENSE_START=======================================================
+ *  Copyright (C) 2019 Nordix Foundation
+ *  ================================================================================
+ *  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.
+ *
+ *  SPDX-License-Identifier: Apache-2.0
+ *  ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation;
+
+/**
+ * Stores non mano artifact types.
+ */
+public enum NonManoArtifactType {
+    ONAP_VES_EVENTS("onap_ves_events"),
+    ONAP_PM_DICTIONARY("onap_pm_dictionary"),
+    ONAP_YANG_MODULES("onap_yang_modules"),
+    ONAP_ANSIBLE_PLAYBOOKS("onap_ansible_playbooks"),
+    ONAP_SCRIPTS("onap_scripts"),
+    ONAP_OTHERS("onap_others");
+
+    private final String type;
+
+    NonManoArtifactType(final String type) {
+        this.type = type;
+    }
+
+    public String getType() {
+        return type;
+    }
+}
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/csar/validation/SOL004MetaDirectoryValidator.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/csar/validation/SOL004MetaDirectoryValidator.java
index 2bd28b389b..bed3a9b128 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/csar/validation/SOL004MetaDirectoryValidator.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/csar/validation/SOL004MetaDirectoryValidator.java
@@ -20,7 +20,9 @@
 
 package org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation;
 
+import java.io.InputStream;
 import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.io.FilenameUtils;
 import org.openecomp.core.impl.ToscaDefinitionImportHandler;
 import org.openecomp.core.utilities.file.FileContentHandler;
 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
@@ -37,7 +39,6 @@ import org.openecomp.sdc.tosca.csar.ToscaMetadata;
 import org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.exceptions.InvalidManifestMetadataException;
 import java.io.IOException;
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -46,6 +47,7 @@ import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
+import org.yaml.snakeyaml.Yaml;
 
 import static org.openecomp.sdc.tosca.csar.CSARConstants.CSAR_VERSION_1_0;
 import static org.openecomp.sdc.tosca.csar.CSARConstants.CSAR_VERSION_1_1;
@@ -66,6 +68,8 @@ import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_META_FILE_VERSION
 import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_META_PATH_FILE_NAME;
 import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_TYPE_PNF;
 import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_TYPE_VNF;
+import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.NonManoArtifactType.ONAP_PM_DICTIONARY;
+import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.NonManoArtifactType.ONAP_VES_EVENTS;
 
 /**
  * Validates the contents of the package to ensure it complies with the "CSAR with TOSCA-Metadata directory" structure
@@ -78,58 +82,73 @@ class SOL004MetaDirectoryValidator implements Validator {
     private static final String MANIFEST_SOURCE = "Source";
     private static final String MANIFEST_NON_MANO_SOURCE = "Non-MANO Source";
     private final List<ErrorMessage> errorsByFile = new ArrayList<>();
+    private FileContentHandler contentHandler;
+    private List<String> folderList;
+    private ToscaMetadata toscaMetadata;
 
     @Override
-    public Map<String, List<ErrorMessage>> validateContent(FileContentHandler contentHandler, List<String> folderList) {
-            validateMetaFile(contentHandler, folderList);
-            return Collections.unmodifiableMap(getAnyValidationErrors());
+    public Map<String, List<ErrorMessage>> validateContent(final FileContentHandler contentHandler
+        , final List<String> folderList) {
+        this.contentHandler = contentHandler;
+        this.folderList = folderList;
+        parseToscaMetadata();
+        verifyMetadataFile();
+        return Collections.unmodifiableMap(getAnyValidationErrors());
     }
 
-    private void validateMetaFile(FileContentHandler contentHandler, List<String> folderList) {
+    /**
+     * Parses the {@link org.openecomp.sdc.tosca.csar.CSARConstants#TOSCA_META_PATH_FILE_NAME} file
+     */
+    private void parseToscaMetadata() {
         try {
-            ToscaMetadata toscaMetadata = OnboardingToscaMetadata.parseToscaMetadataFile(contentHandler.getFileContent(TOSCA_META_PATH_FILE_NAME));
-            if(toscaMetadata.isValid() && hasETSIMetadata(toscaMetadata)) {
-                verifyManifestNameAndExtension(toscaMetadata);
-                handleMetadataEntries(contentHandler, folderList, toscaMetadata);
-            }else {
-                errorsByFile.addAll(toscaMetadata.getErrors());
-            }
-        }catch (IOException e){
+            toscaMetadata =
+                OnboardingToscaMetadata
+                    .parseToscaMetadataFile(contentHandler.getFileContent(TOSCA_META_PATH_FILE_NAME));
+        } catch (final IOException e) {
             reportError(ErrorLevel.ERROR, Messages.METADATA_PARSER_INTERNAL.getErrorMessage());
             LOGGER.error(Messages.METADATA_PARSER_INTERNAL.getErrorMessage(), e.getMessage(), e);
         }
     }
 
-    private void verifyManifestNameAndExtension(ToscaMetadata toscaMetadata) {
-        Map<String, String> entries = toscaMetadata.getMetaEntries();
-        String manifestFileName = getFileName(entries.get(TOSCA_META_ETSI_ENTRY_MANIFEST));
-        String manifestExtension = getFileExtension(entries.get(TOSCA_META_ETSI_ENTRY_MANIFEST));
-        String mainDefinitionFileName= getFileName(entries.get(TOSCA_META_ENTRY_DEFINITIONS));
-        if(!(TOSCA_MANIFEST_FILE_EXT).equals(manifestExtension)){
+    private void verifyMetadataFile() {
+        if (toscaMetadata.isValid() && hasETSIMetadata()) {
+            verifyManifestNameAndExtension();
+            handleMetadataEntries();
+        } else {
+            errorsByFile.addAll(toscaMetadata.getErrors());
+        }
+    }
+
+    private void verifyManifestNameAndExtension() {
+        final Map<String, String> entries = toscaMetadata.getMetaEntries();
+        final String manifestFileName = getFileName(entries.get(TOSCA_META_ETSI_ENTRY_MANIFEST));
+        final String manifestExtension = getFileExtension(entries.get(TOSCA_META_ETSI_ENTRY_MANIFEST));
+        final String mainDefinitionFileName = getFileName(entries.get(TOSCA_META_ENTRY_DEFINITIONS));
+        if (!(TOSCA_MANIFEST_FILE_EXT).equals(manifestExtension)) {
             reportError(ErrorLevel.ERROR, Messages.MANIFEST_INVALID_EXT.getErrorMessage());
         }
-        if(!mainDefinitionFileName.equals(manifestFileName)){
+        if (!mainDefinitionFileName.equals(manifestFileName)) {
             reportError(ErrorLevel.ERROR, String.format(Messages.MANIFEST_INVALID_NAME.getErrorMessage(),
                     manifestFileName, mainDefinitionFileName));
         }
     }
 
-    public String getFileExtension(String filePath){
-        return filePath.substring(filePath.lastIndexOf('.') + 1);
+    private String getFileExtension(final String filePath) {
+        return FilenameUtils.getExtension(filePath);
     }
 
-    private String getFileName(String filePath){
-        return filePath.substring(filePath.lastIndexOf('/') + 1, filePath.lastIndexOf('.'));
+    private String getFileName(final String filePath) {
+        return FilenameUtils.getBaseName(filePath);
     }
 
-    private boolean hasETSIMetadata(ToscaMetadata toscaMetadata){
-        Map<String, String> entries = toscaMetadata.getMetaEntries();
+    private boolean hasETSIMetadata(){
+        final Map<String, String> entries = toscaMetadata.getMetaEntries();
         return hasEntry(entries, TOSCA_META_FILE_VERSION_ENTRY)
                 && hasEntry(entries, TOSCA_META_CSAR_VERSION_ENTRY)
                 && hasEntry(entries, TOSCA_META_CREATED_BY_ENTRY);
     }
 
-    private boolean hasEntry(Map<String, String> entries, String mandatoryEntry) {
+    private boolean hasEntry(final Map<String, String> entries, final String mandatoryEntry) {
         if (!entries.containsKey(mandatoryEntry)) {
             reportError(ErrorLevel.ERROR, String.format(Messages.METADATA_MISSING_ENTRY.getErrorMessage(),mandatoryEntry));
             return false;
@@ -137,15 +156,15 @@ class SOL004MetaDirectoryValidator implements Validator {
         return true;
     }
 
-    private void handleMetadataEntries(FileContentHandler contentHandler, List<String> folderList, ToscaMetadata toscaMetadata) {
-        for(Map.Entry entry: toscaMetadata.getMetaEntries().entrySet()){
-            handleEntry(contentHandler, folderList, toscaMetadata, entry);
+    private void handleMetadataEntries() {
+        for(final Map.Entry entry: toscaMetadata.getMetaEntries().entrySet()){
+            handleEntry(entry);
         }
     }
 
-    private void handleEntry(FileContentHandler contentHandler, List<String> folderList, ToscaMetadata toscaMetadata, Map.Entry entry) {
-        String key = (String) entry.getKey();
-        String value = (String) entry.getValue();
+    private void handleEntry(final Map.Entry<String, String> entry) {
+        final String key = entry.getKey();
+        final String value = entry.getValue();
         switch (key){
             case TOSCA_META_FILE_VERSION_ENTRY:
             case TOSCA_META_CSAR_VERSION_ENTRY:
@@ -153,63 +172,62 @@ class SOL004MetaDirectoryValidator implements Validator {
                 verifyMetadataEntryVersions(key, value);
                 break;
             case TOSCA_META_ENTRY_DEFINITIONS:
-                validateDefinitionFile(contentHandler, value);
+                validateDefinitionFile(value);
                 break;
             case TOSCA_META_ETSI_ENTRY_MANIFEST:
-                validateManifestFile(contentHandler, value);
+                validateManifestFile(value);
                 break;
             case TOSCA_META_ETSI_ENTRY_CHANGE_LOG:
-                validateChangeLog(contentHandler, value);
+                validateChangeLog(value);
                 break;
             case TOSCA_META_ETSI_ENTRY_TESTS:
             case TOSCA_META_ETSI_ENTRY_LICENSES:
-                validateOtherEntries(folderList, entry, contentHandler, toscaMetadata);
+                validateOtherEntries(entry);
                 break;
             case TOSCA_META_ETSI_ENTRY_CERTIFICATE:
-                validateOtherEntries(folderList, value);
+                validateOtherEntries(value);
                 break;
             default:
-                errorsByFile.add(new ErrorMessage(ErrorLevel.ERROR, String.format(Messages.METADATA_UNSUPPORTED_ENTRY.getErrorMessage(), entry)));
+                reportError(ErrorLevel.ERROR, Messages.METADATA_UNSUPPORTED_ENTRY.formatMessage(entry.toString()));
                 LOGGER.warn(Messages.METADATA_UNSUPPORTED_ENTRY.getErrorMessage(), entry);
                 break;
         }
     }
 
-    private void validateOtherEntries(List<String> folderList, Map.Entry entry, FileContentHandler contentHandler, ToscaMetadata toscaMetadata) {
-        String manifestFile = toscaMetadata.getMetaEntries().get(TOSCA_META_ETSI_ENTRY_MANIFEST);
+    private void validateOtherEntries(final Map.Entry entry) {
+        final String manifestFile = toscaMetadata.getMetaEntries().get(TOSCA_META_ETSI_ENTRY_MANIFEST);
         if(verifyFileExists(contentHandler.getFileList(), manifestFile)){
-            Manifest onboardingManifest = new SOL004ManifestOnboarding();
+            final Manifest onboardingManifest = new SOL004ManifestOnboarding();
             onboardingManifest.parse(contentHandler.getFileContent(manifestFile));
-            Optional<ResourceTypeEnum> resourceType = onboardingManifest.getType();
-            if(resourceType.isPresent() && resourceType.get() == ResourceTypeEnum.VF){
-                String value = (String) entry.getValue();
-                validateOtherEntries(folderList, value);
-            }else{
-                String key = (String) entry.getKey();
+            final Optional<ResourceTypeEnum> resourceType = onboardingManifest.getType();
+            if (resourceType.isPresent() && resourceType.get() == ResourceTypeEnum.VF){
+                final String value = (String) entry.getValue();
+                validateOtherEntries(value);
+            } else {
+                final String key = (String) entry.getKey();
                 reportError(ErrorLevel.ERROR, String.format(Messages.MANIFEST_INVALID_PNF_METADATA.getErrorMessage(), key));
             }
 
         }
     }
 
-
-    private void verifyMetadataEntryVersions(String key, String version) {
+    private void verifyMetadataEntryVersions(final String key, final String version) {
         if(!(isValidTOSCAVersion(key,version) || isValidCSARVersion(key, version) || TOSCA_META_CREATED_BY_ENTRY.equals(key))) {
             errorsByFile.add(new ErrorMessage(ErrorLevel.ERROR, String.format(Messages.METADATA_INVALID_VERSION.getErrorMessage(), key, version)));
             LOGGER.error("{}: key {} - value {} ", Messages.METADATA_INVALID_VERSION.getErrorMessage(), key, version);
         }
     }
 
-    private boolean isValidTOSCAVersion(String key, String version){
+    private boolean isValidTOSCAVersion(final String key, final String version){
         return TOSCA_META_FILE_VERSION_ENTRY.equals(key) && TOSCA_META_FILE_VERSION.equals(version);
     }
 
-    private boolean isValidCSARVersion(String value, String version){
+    private boolean isValidCSARVersion(final String value, final String version){
         return TOSCA_META_CSAR_VERSION_ENTRY.equals(value) && (CSAR_VERSION_1_1.equals(version)
                 || CSAR_VERSION_1_0.equals(version));
     }
 
-    private void validateDefinitionFile(final FileContentHandler contentHandler, final String filePath) {
+    private void validateDefinitionFile(final String filePath) {
         final Set<String> existingFiles = contentHandler.getFileList();
 
         if (verifyFileExists(existingFiles, filePath)) {
@@ -224,68 +242,67 @@ class SOL004MetaDirectoryValidator implements Validator {
         }
     }
 
-    private boolean verifyFileExists(Set<String> existingFiles, String filePath){
+    private boolean verifyFileExists(final Set<String> existingFiles, final String filePath) {
         return existingFiles.contains(filePath);
     }
 
-    private void validateManifestFile(FileContentHandler contentHandler, String filePath){
+    private void validateManifestFile(final String filePath) {
         final Set<String> existingFiles = contentHandler.getFileList();
         if (verifyFileExists(existingFiles, filePath)) {
-            Manifest onboardingManifest = new SOL004ManifestOnboarding();
+            final Manifest onboardingManifest = new SOL004ManifestOnboarding();
             onboardingManifest.parse(contentHandler.getFileContent(filePath));
-            if(onboardingManifest.isValid()){
+            if (onboardingManifest.isValid()) {
                 try {
                     verifyManifestMetadata(onboardingManifest.getMetadata());
-                }catch (InvalidManifestMetadataException e){
-                   reportError(ErrorLevel.ERROR, e.getMessage());
-                   LOGGER.error(e.getMessage(), e);
-                }
-                verifyManifestSources(existingFiles, onboardingManifest);
-            }else{
-                List<String> manifestErrors = onboardingManifest.getErrors();
-                for(String error: manifestErrors){
-                    reportError(ErrorLevel.ERROR, error);
+                } catch (final InvalidManifestMetadataException e) {
+                    reportError(ErrorLevel.ERROR, e.getMessage());
+                    LOGGER.error(e.getMessage(), e);
                 }
+                verifyManifestSources(onboardingManifest);
+            } else {
+                final List<String> manifestErrors = onboardingManifest.getErrors();
+                manifestErrors.forEach(error -> reportError(ErrorLevel.ERROR, error));
             }
-        }else {
+        } else {
             reportError(ErrorLevel.ERROR, String.format(Messages.MANIFEST_NOT_FOUND.getErrorMessage(), filePath));
         }
     }
 
-    private void verifyManifestMetadata(Map<String, String> metadata) {
-        if(metadata.size() != MANIFEST_METADATA_LIMIT){
-            reportError(ErrorLevel.ERROR, String.format(Messages.MANIFEST_METADATA_DOES_NOT_MATCH_LIMIT.getErrorMessage(),
+    private void verifyManifestMetadata(final Map<String, String> metadata) {
+        if (metadata.size() != MANIFEST_METADATA_LIMIT) {
+            reportError(ErrorLevel.ERROR,
+                String.format(Messages.MANIFEST_METADATA_DOES_NOT_MATCH_LIMIT.getErrorMessage(),
                     MANIFEST_METADATA_LIMIT));
         }
-        if(isPnfMetadata(metadata)){
+        if (isPnfMetadata(metadata)) {
             handlePnfMetadataEntries(metadata);
-        }else {
+        } else {
             handleVnfMetadataEntries(metadata);
         }
     }
 
-    private boolean isPnfMetadata(Map<String, String> metadata) {
-        String metadataType = "";
-        for(String key: metadata.keySet()) {
-            if(metadataType.isEmpty()){
-                 metadataType = key.contains(TOSCA_TYPE_PNF) ? TOSCA_TYPE_PNF : TOSCA_TYPE_VNF;
-            }else if(!key.contains(metadataType)){
-                throw new InvalidManifestMetadataException(Messages.MANIFEST_METADATA_INVALID_ENTRY.getErrorMessage());
-            }
+    private boolean isPnfMetadata(final Map<String, String> metadata) {
+        final String firstMetadataDefinition = metadata.keySet().iterator().next();
+        final String expectedMetadataType =
+            firstMetadataDefinition.contains(TOSCA_TYPE_PNF) ? TOSCA_TYPE_PNF : TOSCA_TYPE_VNF;
+        if (metadata.keySet().stream()
+            .anyMatch((final String metadataEntry) -> !metadataEntry.contains(expectedMetadataType))) {
+            throw new InvalidManifestMetadataException(Messages.MANIFEST_METADATA_INVALID_ENTRY.getErrorMessage());
         }
-        return TOSCA_TYPE_PNF.equals(metadataType);
+
+        return TOSCA_TYPE_PNF.equals(expectedMetadataType);
     }
 
-    private void handleVnfMetadataEntries(Map<String, String> metadata) {
-        for (String requiredVnfEntry : MANIFEST_VNF_METADATA) {
+    private void handleVnfMetadataEntries(final Map<String, String> metadata) {
+        for (final String requiredVnfEntry : MANIFEST_VNF_METADATA) {
             if (!metadata.containsKey(requiredVnfEntry)) {
                 reportError(ErrorLevel.ERROR, String.format(Messages.MANIFEST_METADATA_MISSING_ENTRY.getErrorMessage(), requiredVnfEntry));
             }
         }
     }
 
-    private void handlePnfMetadataEntries(Map<String, String> metadata) {
-        for (String requiredPnfEntry : MANIFEST_PNF_METADATA) {
+    private void handlePnfMetadataEntries(final Map<String, String> metadata) {
+        for (final String requiredPnfEntry : MANIFEST_PNF_METADATA) {
             if (!metadata.containsKey(requiredPnfEntry)) {
                 reportError(ErrorLevel.ERROR, String.format(Messages.MANIFEST_METADATA_MISSING_ENTRY.getErrorMessage(), requiredPnfEntry));
             }
@@ -295,27 +312,61 @@ class SOL004MetaDirectoryValidator implements Validator {
     /**
      * Checks if all manifest sources exists within the package and if all package files are being referred.
      *
-     * @param packageFiles          The package file path list
      * @param onboardingManifest    The manifest
      */
-    private void verifyManifestSources(final Set<String> packageFiles, final Manifest onboardingManifest) {
+    private void verifyManifestSources(final Manifest onboardingManifest) {
+        final Set<String> packageFiles = contentHandler.getFileList();
         final List<String> sources = filterSources(onboardingManifest.getSources());
         verifyFilesExist(packageFiles, sources, MANIFEST_SOURCE);
 
         final Map<String, List<String>> nonManoArtifacts = onboardingManifest.getNonManoSources();
-        final List<String> nonManoFiles = nonManoArtifacts.values().stream()
-            .map(this::filterSources)
-            .flatMap(Collection::stream)
-            .collect(Collectors.toList());
-        verifyFilesExist(packageFiles, nonManoFiles, MANIFEST_NON_MANO_SOURCE);
+
+        final List<String> nonManoValidFilePaths = new ArrayList<>();
+        nonManoArtifacts.forEach((nonManoType, files) -> {
+            final List<String> internalNonManoFileList = filterSources(files);
+            nonManoValidFilePaths.addAll(internalNonManoFileList);
+            if (ONAP_PM_DICTIONARY.getType().equals(nonManoType) || ONAP_VES_EVENTS.getType().equals(nonManoType)) {
+                internalNonManoFileList.forEach(this::validateYaml);
+            }
+        });
+
+        verifyFilesExist(packageFiles, nonManoValidFilePaths, MANIFEST_NON_MANO_SOURCE);
 
         final Set<String> allReferredFiles = new HashSet<>();
         allReferredFiles.addAll(sources);
-        allReferredFiles.addAll(nonManoFiles);
+        allReferredFiles.addAll(nonManoValidFilePaths);
         verifyFilesBeingReferred(allReferredFiles, packageFiles);
     }
 
     /**
+     * Validates if a YAML file has the correct extension, is not empty and the content is a valid YAML.
+     * Reports each error found.
+     *
+     * @param filePath  the file path inside the package
+     */
+    private void validateYaml(final String filePath) {
+        if (!contentHandler.containsFile(filePath)) {
+            return;
+        }
+        final String fileExtension = getFileExtension(filePath);
+        if (!"yaml".equalsIgnoreCase(fileExtension) && !"yml".equalsIgnoreCase(fileExtension)) {
+            reportError(ErrorLevel.ERROR, Messages.INVALID_YAML_EXTENSION.formatMessage(filePath));
+            return;
+        }
+
+        final InputStream fileContent = contentHandler.getFileContent(filePath);
+        if (fileContent == null) {
+            reportError(ErrorLevel.ERROR, Messages.EMPTY_YAML_FILE_1.formatMessage(filePath));
+            return;
+        }
+        try {
+            new Yaml().loadAll(fileContent).iterator().next();
+        } catch (final Exception e) {
+            reportError(ErrorLevel.ERROR, Messages.INVALID_YAML_FORMAT_1.formatMessage(filePath, e.getMessage()));
+        }
+    }
+
+    /**
      * Checks if all package files are referred in manifest.
      * Reports missing references.
      *
@@ -330,36 +381,35 @@ class SOL004MetaDirectoryValidator implements Validator {
         });
     }
 
-    private List<String> filterSources(List<String> source){
+    private List<String> filterSources(final List<String> source){
         return source.stream()
                 .filter(this::externalFileReferences)
                 .collect(Collectors.toList());
     }
 
-    private boolean externalFileReferences(String filePath){
+    private boolean externalFileReferences(final String filePath){
         return !filePath.contains("://");
     }
 
-    private void validateOtherEntries(List<String> folderList, String folderPath){
+    private void validateOtherEntries(final String folderPath) {
         if(!verifyFoldersExist(folderList, folderPath))
             reportError(ErrorLevel.ERROR, String.format(Messages.METADATA_MISSING_OPTIONAL_FOLDERS.getErrorMessage(),
                     folderPath));
     }
 
-    private boolean verifyFoldersExist(List<String> folderList, String folderPath){
+    private boolean verifyFoldersExist(final List<String> folderList, final String folderPath) {
         return folderList.contains(folderPath + "/");
     }
 
-    private void verifyFilesExist(Set<String> existingFiles, List<String> sources, String type){
-        for(String file: sources){
-            if(!verifyFileExists(existingFiles, file)){
+    private void verifyFilesExist(final Set<String> existingFiles, final List<String> sources, final String type) {
+        sources.forEach(file -> {
+            if(!existingFiles.contains(file)){
                 reportError(ErrorLevel.ERROR, String.format(Messages.MISSING_MANIFEST_SOURCE.getErrorMessage(), type, file));
             }
-
-        }
+        });
     }
 
-    private void validateChangeLog(FileContentHandler contentHandler, String filePath){
+    private void validateChangeLog(final String filePath) {
         if(!verifyFileExists(contentHandler.getFileList(), filePath)){
             reportError(ErrorLevel.ERROR, String.format(Messages.MISSING_METADATA_FILES.getErrorMessage(), filePath));
         }
@@ -369,12 +419,11 @@ class SOL004MetaDirectoryValidator implements Validator {
         errorsByFile.add(new ErrorMessage(errorLevel, errorMessage));
     }
 
-    private Map<String, List<ErrorMessage>> getAnyValidationErrors(){
-
-        if(errorsByFile.isEmpty()){
+    private Map<String, List<ErrorMessage>> getAnyValidationErrors() {
+        if (errorsByFile.isEmpty()) {
             return Collections.emptyMap();
         }
-        Map<String, List<ErrorMessage>> errors = new HashMap<>();
+        final Map<String, List<ErrorMessage>> errors = new HashMap<>();
         errors.put(SdcCommon.UPLOAD_FILE, errorsByFile);
         return errors;
     }