X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=cps-ri%2Fsrc%2Fmain%2Fjava%2Forg%2Fonap%2Fcps%2Fspi%2Fimpl%2FCpsModulePersistenceServiceImpl.java;h=136512077cf44b8e0c42cff8c59c8398ab718a54;hb=240ac3d9cd8107250574dd0f7221ae2f1afa3bd7;hp=e63ae5962f430be1a79c65ceeda2c73b7d22f23d;hpb=57bb1d811eac4011bfcdf3be1ea60d869879c147;p=cps.git diff --git a/cps-ri/src/main/java/org/onap/cps/spi/impl/CpsModulePersistenceServiceImpl.java b/cps-ri/src/main/java/org/onap/cps/spi/impl/CpsModulePersistenceServiceImpl.java old mode 100644 new mode 100755 index e63ae5962..136512077 --- a/cps-ri/src/main/java/org/onap/cps/spi/impl/CpsModulePersistenceServiceImpl.java +++ b/cps-ri/src/main/java/org/onap/cps/spi/impl/CpsModulePersistenceServiceImpl.java @@ -1,13 +1,16 @@ /* - * ============LICENSE_START======================================================= - * Copyright (C) 2020 Nordix Foundation - * Modifications Copyright (C) 2020 Bell Canada. All rights reserved. + * ============LICENSE_START======================================================= + * Copyright (C) 2020-2023 Nordix Foundation + * Modifications Copyright (C) 2020-2022 Bell Canada. + * Modifications Copyright (C) 2021 Pantheon.tech + * Modifications Copyright (C) 2022 TechMahindra Ltd. * ================================================================================ * 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. @@ -20,88 +23,351 @@ package org.onap.cps.spi.impl; +import static com.google.common.base.Preconditions.checkNotNull; + +import com.google.common.base.MoreObjects; import com.google.common.collect.ImmutableSet; +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.nio.charset.StandardCharsets; +import java.util.Collection; +import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.Set; +import java.util.regex.Matcher; +import java.util.regex.Pattern; import java.util.stream.Collectors; import javax.transaction.Transactional; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.codec.digest.DigestUtils; +import org.apache.commons.lang3.StringUtils; +import org.hibernate.exception.ConstraintViolationException; +import org.onap.cps.spi.CpsAdminPersistenceService; import org.onap.cps.spi.CpsModulePersistenceService; -import org.onap.cps.spi.entities.Dataspace; -import org.onap.cps.spi.entities.SchemaSet; -import org.onap.cps.spi.entities.YangResource; -import org.onap.cps.spi.exceptions.SchemaSetAlreadyDefinedException; +import org.onap.cps.spi.entities.DataspaceEntity; +import org.onap.cps.spi.entities.SchemaSetEntity; +import org.onap.cps.spi.entities.YangResourceEntity; +import org.onap.cps.spi.entities.YangResourceModuleReference; +import org.onap.cps.spi.exceptions.AlreadyDefinedException; +import org.onap.cps.spi.exceptions.DuplicatedYangResourceException; +import org.onap.cps.spi.exceptions.ModelValidationException; +import org.onap.cps.spi.model.ModuleDefinition; +import org.onap.cps.spi.model.ModuleReference; +import org.onap.cps.spi.model.SchemaSet; import org.onap.cps.spi.repository.DataspaceRepository; +import org.onap.cps.spi.repository.ModuleReferenceRepository; import org.onap.cps.spi.repository.SchemaSetRepository; import org.onap.cps.spi.repository.YangResourceRepository; -import org.springframework.beans.factory.annotation.Autowired; +import org.opendaylight.yangtools.yang.common.Revision; +import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier; +import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource; +import org.opendaylight.yangtools.yang.parser.api.YangSyntaxErrorException; +import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YangModelDependencyInfo; import org.springframework.dao.DataIntegrityViolationException; +import org.springframework.retry.annotation.Backoff; +import org.springframework.retry.annotation.Retryable; +import org.springframework.retry.support.RetrySynchronizationManager; import org.springframework.stereotype.Component; -import org.springframework.util.DigestUtils; +@Slf4j @Component +@RequiredArgsConstructor public class CpsModulePersistenceServiceImpl implements CpsModulePersistenceService { - @Autowired - private YangResourceRepository yangResourceRepository; + private static final String YANG_RESOURCE_CHECKSUM_CONSTRAINT_NAME = "yang_resource_checksum_key"; + private static final Pattern CHECKSUM_EXCEPTION_PATTERN = Pattern.compile(".*\\(checksum\\)=\\((\\w+)\\).*"); + private static final Pattern RFC6020_RECOMMENDED_FILENAME_PATTERN = Pattern + .compile("([\\w-]+)@(\\d{4}-\\d{2}-\\d{2})(?:\\.yang)?", Pattern.CASE_INSENSITIVE); + + private final YangResourceRepository yangResourceRepository; + + private final SchemaSetRepository schemaSetRepository; + + private final DataspaceRepository dataspaceRepository; - @Autowired - private SchemaSetRepository schemaSetRepository; + private final CpsAdminPersistenceService cpsAdminPersistenceService; - @Autowired - private DataspaceRepository dataspaceRepository; + private final ModuleReferenceRepository moduleReferenceRepository; @Override - public void storeModule(final String namespace, final String moduleContent, final String revision, - final String dataspaceName) { - // TODO this method should be removed as obsolete. - // Modules to be processed within schema sets only. + public Map getYangSchemaResources(final String dataspaceName, final String schemaSetName) { + final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName); + final SchemaSetEntity schemaSetEntity = + schemaSetRepository.getByDataspaceAndName(dataspaceEntity, schemaSetName); + return schemaSetEntity.getYangResources().stream().collect( + Collectors.toMap(YangResourceEntity::getFileName, YangResourceEntity::getContent)); + } + + @Override + public Collection getYangResourceModuleReferences(final String dataspaceName) { + final Set yangResourceModuleReferenceList = + yangResourceRepository.findAllModuleReferencesByDataspace(dataspaceName); + return yangResourceModuleReferenceList.stream().map(CpsModulePersistenceServiceImpl::toModuleReference) + .collect(Collectors.toList()); + } + + @Override + public Collection getYangResourceModuleReferences(final String dataspaceName, + final String anchorName) { + final Set yangResourceModuleReferenceList = + yangResourceRepository + .findAllModuleReferencesByDataspaceAndAnchor(dataspaceName, anchorName); + return yangResourceModuleReferenceList.stream().map(CpsModulePersistenceServiceImpl::toModuleReference) + .collect(Collectors.toList()); + } + + @Override + public Collection getYangResourceDefinitions(final String dataspaceName, + final String anchorName) { + final Set yangResourceEntities = + yangResourceRepository + .findAllModuleDefinitionsByDataspaceAndAnchor(dataspaceName, anchorName); + return yangResourceEntities.stream().map(CpsModulePersistenceServiceImpl::toModuleDefinition) + .collect(Collectors.toList()); } @Override @Transactional + // A retry is made to store the schema set if it fails because of duplicated yang resource exception that + // can occur in case of specific concurrent requests. + @Retryable(value = DuplicatedYangResourceException.class, maxAttempts = 5, backoff = + @Backoff(random = true, delay = 200, maxDelay = 2000, multiplier = 2)) public void storeSchemaSet(final String dataspaceName, final String schemaSetName, - final Set yangResourcesAsStrings) { - - final Dataspace dataspace = dataspaceRepository.getByName(dataspaceName); - final Set yangResources = synchronizeYangResources(yangResourcesAsStrings); - final SchemaSet schemaSet = new SchemaSet(); - schemaSet.setName(schemaSetName); - schemaSet.setDataspace(dataspace); - schemaSet.setYangResources(yangResources); + final Map moduleReferenceNameToContentMap) { + final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName); + final Set yangResourceEntities = synchronizeYangResources(moduleReferenceNameToContentMap); + final SchemaSetEntity schemaSetEntity = new SchemaSetEntity(); + schemaSetEntity.setName(schemaSetName); + schemaSetEntity.setDataspace(dataspaceEntity); + schemaSetEntity.setYangResources(yangResourceEntities); try { - schemaSetRepository.save(schemaSet); + schemaSetRepository.save(schemaSetEntity); } catch (final DataIntegrityViolationException e) { - throw new SchemaSetAlreadyDefinedException(dataspaceName, schemaSetName, e); + throw AlreadyDefinedException.forSchemaSet(schemaSetName, dataspaceName, e); } } - private Set synchronizeYangResources(final Set yangResourcesAsStrings) { - final Map checksumToContentMap = yangResourcesAsStrings.stream() - .collect(Collectors.toMap( - content -> DigestUtils.md5DigestAsHex(content.getBytes()), - content -> content) - ); + @Override + public Collection getSchemaSetsByDataspaceName(final String dataspaceName) { + final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName); + final List schemaSetEntities = schemaSetRepository.findByDataspace(dataspaceEntity); + return schemaSetEntities.stream() + .map(CpsModulePersistenceServiceImpl::toSchemaSet).collect(Collectors.toList()); + } - final List existingYangResources = - yangResourceRepository.findAllByChecksumIn(checksumToContentMap.keySet()); - existingYangResources.forEach(yangFile -> checksumToContentMap.remove(yangFile.getChecksum())); + @Override + @Transactional + // A retry is made to store the schema set if it fails because of duplicated yang resource exception that + // can occur in case of specific concurrent requests. + @Retryable(value = DuplicatedYangResourceException.class, maxAttempts = 5, backoff = + @Backoff(random = true, delay = 200, maxDelay = 2000, multiplier = 2)) + public void storeSchemaSetFromModules(final String dataspaceName, final String schemaSetName, + final Map newModuleNameToContentMap, + final Collection allModuleReferences) { + storeSchemaSet(dataspaceName, schemaSetName, newModuleNameToContentMap); + final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName); + final SchemaSetEntity schemaSetEntity = + schemaSetRepository.getByDataspaceAndName(dataspaceEntity, schemaSetName); + final List allYangResourceIds = + yangResourceRepository.getResourceIdsByModuleReferences(allModuleReferences); + yangResourceRepository.insertSchemaSetIdYangResourceId(schemaSetEntity.getId(), allYangResourceIds); + } - final List newYangResources = checksumToContentMap.entrySet().stream() + @Override + @Transactional + public void deleteSchemaSet(final String dataspaceName, final String schemaSetName) { + final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName); + final SchemaSetEntity schemaSetEntity = + schemaSetRepository.getByDataspaceAndName(dataspaceEntity, schemaSetName); + schemaSetRepository.delete(schemaSetEntity); + } + + @Override + @Transactional + public void deleteSchemaSets(final String dataspaceName, final Collection schemaSetNames) { + final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName); + schemaSetRepository.deleteByDataspaceAndNameIn(dataspaceEntity, schemaSetNames); + } + + @Override + @Transactional + public void deleteUnusedYangResourceModules() { + yangResourceRepository.deleteOrphans(); + } + + @Override + public Collection identifyNewModuleReferences( + final Collection moduleReferencesToCheck) { + return moduleReferenceRepository.identifyNewModuleReferences(moduleReferencesToCheck); + } + + private Set synchronizeYangResources( + final Map moduleReferenceNameToContentMap) { + final Map checksumToEntityMap = moduleReferenceNameToContentMap.entrySet().stream() .map(entry -> { - final YangResource yangResource = new YangResource(); - yangResource.setChecksum(entry.getKey()); - yangResource.setContent(entry.getValue()); - return yangResource; - }).collect(Collectors.toList()); - if (!newYangResources.isEmpty()) { - yangResourceRepository.saveAll(newYangResources); + final String checksum = DigestUtils.sha256Hex(entry.getValue().getBytes(StandardCharsets.UTF_8)); + final Map moduleNameAndRevisionMap = createModuleNameAndRevisionMap(entry.getKey(), + entry.getValue()); + final YangResourceEntity yangResourceEntity = new YangResourceEntity(); + yangResourceEntity.setFileName(entry.getKey()); + yangResourceEntity.setContent(entry.getValue()); + yangResourceEntity.setModuleName(moduleNameAndRevisionMap.get("moduleName")); + yangResourceEntity.setRevision(moduleNameAndRevisionMap.get("revision")); + yangResourceEntity.setChecksum(checksum); + return yangResourceEntity; + }) + .collect(Collectors.toMap( + YangResourceEntity::getChecksum, + entity -> entity + )); + + final List existingYangResourceEntities = + yangResourceRepository.findAllByChecksumIn(checksumToEntityMap.keySet()); + existingYangResourceEntities.forEach(yangFile -> checksumToEntityMap.remove(yangFile.getChecksum())); + + final Collection newYangResourceEntities = checksumToEntityMap.values(); + if (!newYangResourceEntities.isEmpty()) { + try { + yangResourceRepository.saveAll(newYangResourceEntities); + } catch (final DataIntegrityViolationException dataIntegrityViolationException) { + // Throw a CPS duplicated Yang resource exception if the cause of the error is a yang checksum + // database constraint violation. + // If it is not, then throw the original exception + final Optional convertedException = + convertToDuplicatedYangResourceException( + dataIntegrityViolationException, newYangResourceEntities); + convertedException.ifPresent( + e -> { + int retryCount = RetrySynchronizationManager.getContext() == null ? 0 + : RetrySynchronizationManager.getContext().getRetryCount(); + log.warn("Cannot persist duplicated yang resource. System will attempt this method " + + "up to 5 times. Current retry count : {}", ++retryCount, e); + }); + throw convertedException.isPresent() ? convertedException.get() : dataIntegrityViolationException; + } } - return ImmutableSet.builder() - .addAll(existingYangResources) - .addAll(newYangResources) + return ImmutableSet.builder() + .addAll(existingYangResourceEntities) + .addAll(newYangResourceEntities) .build(); } + private static Map createModuleNameAndRevisionMap(final String sourceName, final String source) { + final Map metaDataMap = new HashMap<>(); + final RevisionSourceIdentifier revisionSourceIdentifier = + createIdentifierFromSourceName(checkNotNull(sourceName)); + + final YangTextSchemaSource tempYangTextSchemaSource = new YangTextSchemaSource(revisionSourceIdentifier) { + @Override + public Optional getSymbolicName() { + return Optional.empty(); + } + + @Override + protected MoreObjects.ToStringHelper addToStringAttributes( + final MoreObjects.ToStringHelper toStringHelper) { + return toStringHelper; + } + + @Override + public InputStream openStream() { + return new ByteArrayInputStream(source.getBytes(StandardCharsets.UTF_8)); + } + }; + try { + final YangModelDependencyInfo yangModelDependencyInfo + = YangModelDependencyInfo.forYangText(tempYangTextSchemaSource); + metaDataMap.put("moduleName", yangModelDependencyInfo.getName()); + metaDataMap.put("revision", yangModelDependencyInfo.getFormattedRevision()); + } catch (final YangSyntaxErrorException | IOException e) { + throw new ModelValidationException("Yang resource is invalid.", + String.format("Yang syntax validation failed for resource %s:%n%s", sourceName, e.getMessage()), e); + } + return metaDataMap; + } + + private static RevisionSourceIdentifier createIdentifierFromSourceName(final String sourceName) { + final Matcher matcher = RFC6020_RECOMMENDED_FILENAME_PATTERN.matcher(sourceName); + if (matcher.matches()) { + return RevisionSourceIdentifier.create(matcher.group(1), Revision.of(matcher.group(2))); + } + return RevisionSourceIdentifier.create(sourceName); + } + + /** + * Convert the specified data integrity violation exception into a CPS duplicated Yang resource exception + * if the cause of the error is a yang checksum database constraint violation. + * + * @param originalException the original db exception. + * @param yangResourceEntities the collection of Yang resources involved in the db failure. + * @return an optional converted CPS duplicated Yang resource exception. The optional is empty if the original + * cause of the error is not a yang checksum database constraint violation. + */ + private Optional convertToDuplicatedYangResourceException( + final DataIntegrityViolationException originalException, + final Collection yangResourceEntities) { + + // The exception result + DuplicatedYangResourceException duplicatedYangResourceException = null; + + final Throwable cause = originalException.getCause(); + if (cause instanceof ConstraintViolationException) { + final ConstraintViolationException constraintException = (ConstraintViolationException) cause; + if (YANG_RESOURCE_CHECKSUM_CONSTRAINT_NAME.equals(constraintException.getConstraintName())) { + // Db constraint related to yang resource checksum uniqueness is not respected + final String checksumInError = getDuplicatedChecksumFromException(constraintException); + final String nameInError = getNameForChecksum(checksumInError, yangResourceEntities); + duplicatedYangResourceException = + new DuplicatedYangResourceException(nameInError, checksumInError, constraintException); + } + } + + return Optional.ofNullable(duplicatedYangResourceException); + + } + + private String getNameForChecksum(final String checksum, + final Collection yangResourceEntities) { + final Optional optionalFileName = yangResourceEntities.stream() + .filter(entity -> StringUtils.equals(checksum, (entity.getChecksum()))) + .findFirst() + .map(YangResourceEntity::getFileName); + if (optionalFileName.isPresent()) { + return optionalFileName.get(); + } + return "no filename"; + } + + private String getDuplicatedChecksumFromException(final ConstraintViolationException exception) { + final Matcher matcher = CHECKSUM_EXCEPTION_PATTERN.matcher(exception.getSQLException().getMessage()); + if (matcher.find()) { + return matcher.group(1); + } + return "no checksum found"; + } + + private static ModuleReference toModuleReference( + final YangResourceModuleReference yangResourceModuleReference) { + return ModuleReference.builder() + .moduleName(yangResourceModuleReference.getModuleName()) + .revision(yangResourceModuleReference.getRevision()) + .build(); + } + + private static ModuleDefinition toModuleDefinition(final YangResourceEntity yangResourceEntity) { + return new ModuleDefinition( + yangResourceEntity.getModuleName(), + yangResourceEntity.getRevision(), + yangResourceEntity.getContent()); + } + + private static SchemaSet toSchemaSet(final SchemaSetEntity schemaSetEntity) { + return SchemaSet.builder().name(schemaSetEntity.getName()) + .dataspaceName(schemaSetEntity.getDataspace().getName()).build(); + } }