/*
* ============LICENSE_START=======================================================
- * Copyright (C) 2020-2023 Nordix Foundation
+ * Copyright (C) 2020-2024 Nordix Foundation
* Modifications Copyright (C) 2020-2022 Bell Canada.
* Modifications Copyright (C) 2021 Pantheon.tech
* Modifications Copyright (C) 2022 TechMahindra Ltd.
import com.google.common.base.MoreObjects;
import com.google.common.collect.ImmutableSet;
+import jakarta.transaction.Transactional;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
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.DataspaceEntity;
import org.onap.cps.spi.entities.SchemaSetEntity;
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.RetryContext;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Retryable;
import org.springframework.retry.support.RetrySynchronizationManager;
public class CpsModulePersistenceServiceImpl implements CpsModulePersistenceService {
private static final String YANG_RESOURCE_CHECKSUM_CONSTRAINT_NAME = "yang_resource_checksum_key";
+ private static final String NO_MODULE_NAME_FILTER = null;
+ private static final String NO_MODULE_REVISION = null;
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 DataspaceRepository dataspaceRepository;
- private final CpsAdminPersistenceService cpsAdminPersistenceService;
-
private final ModuleReferenceRepository moduleReferenceRepository;
@Override
public Collection<ModuleDefinition> getYangResourceDefinitions(final String dataspaceName,
final String anchorName) {
final Set<YangResourceEntity> yangResourceEntities =
- yangResourceRepository
- .findAllModuleDefinitionsByDataspaceAndAnchor(dataspaceName, anchorName);
- return yangResourceEntities.stream().map(CpsModulePersistenceServiceImpl::toModuleDefinition)
- .collect(Collectors.toList());
+ yangResourceRepository.findAllModuleDefinitionsByDataspaceAndAnchorAndModule(dataspaceName, anchorName,
+ NO_MODULE_NAME_FILTER, NO_MODULE_REVISION);
+ return convertYangResourceEntityToModuleDefinition(yangResourceEntities);
+ }
+
+ @Override
+ public Collection<ModuleDefinition> getYangResourceDefinitionsByAnchorAndModule(final String dataspaceName,
+ final String anchorName,
+ final String moduleName,
+ final String moduleRevision) {
+ final Set<YangResourceEntity> yangResourceEntities =
+ yangResourceRepository.findAllModuleDefinitionsByDataspaceAndAnchorAndModule(dataspaceName, anchorName,
+ moduleName, moduleRevision);
+ return convertYangResourceEntityToModuleDefinition(yangResourceEntities);
+ }
+
+ private List<ModuleDefinition> convertYangResourceEntityToModuleDefinition(final Set<YangResourceEntity>
+ yangResourceEntities) {
+ final List<ModuleDefinition> resultModuleDefinitions = new ArrayList<>(yangResourceEntities.size());
+ for (final YangResourceEntity yangResourceEntity: yangResourceEntities) {
+ resultModuleDefinitions.add(toModuleDefinition(yangResourceEntity));
+ }
+ return resultModuleDefinitions;
}
@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 =
+ @Retryable(retryFor = DuplicatedYangResourceException.class, maxAttempts = 5, backoff =
@Backoff(random = true, delay = 200, maxDelay = 2000, multiplier = 2))
public void storeSchemaSet(final String dataspaceName, final String schemaSetName,
final Map<String, String> moduleReferenceNameToContentMap) {
@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 =
+ @Retryable(retryFor = 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<String, String> newModuleNameToContentMap,
schemaSetRepository.deleteByDataspaceAndNameIn(dataspaceEntity, schemaSetNames);
}
+
+ @Override
+ @Transactional
+ public void updateSchemaSetFromModules(final String dataspaceName, final String schemaSetName,
+ final Map<String, String> newModuleNameToContentMap,
+ final Collection<ModuleReference> allModuleReferences) {
+ final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
+ final SchemaSetEntity schemaSetEntity =
+ schemaSetRepository.getByDataspaceAndName(dataspaceEntity, schemaSetName);
+ storeAndLinkNewModules(newModuleNameToContentMap, schemaSetEntity);
+ updateAllModuleReferences(allModuleReferences, schemaSetEntity.getId());
+ }
+
+
+
@Override
@Transactional
public void deleteUnusedYangResourceModules() {
dataIntegrityViolationException, newYangResourceEntities);
convertedException.ifPresent(
e -> {
- int retryCount = RetrySynchronizationManager.getContext() == null ? 0
- : RetrySynchronizationManager.getContext().getRetryCount();
+ final RetryContext retryContext = RetrySynchronizationManager.getContext();
+ int retryCount = retryContext == null ? 0 : retryContext.getRetryCount();
log.warn("Cannot persist duplicated yang resource. System will attempt this method "
+ "up to 5 times. Current retry count : {}", ++retryCount, e);
});
.filter(entity -> StringUtils.equals(checksum, (entity.getChecksum())))
.findFirst()
.map(YangResourceEntity::getFileName);
- if (optionalFileName.isPresent()) {
- return optionalFileName.get();
- }
- return null;
+ return optionalFileName.orElse("no filename");
}
private String getDuplicatedChecksumFromException(final ConstraintViolationException exception) {
final Matcher matcher = CHECKSUM_EXCEPTION_PATTERN.matcher(exception.getSQLException().getMessage());
- if (matcher.find() && matcher.groupCount() == 1) {
+ if (matcher.find()) {
return matcher.group(1);
}
- return null;
+ return "no checksum found";
}
private static ModuleReference toModuleReference(
return SchemaSet.builder().name(schemaSetEntity.getName())
.dataspaceName(schemaSetEntity.getDataspace().getName()).build();
}
+
+ private void storeAndLinkNewModules(final Map<String, String> newModuleNameToContentMap,
+ final SchemaSetEntity schemaSetEntity) {
+ final Set<YangResourceEntity> yangResourceEntities
+ = new HashSet<>(synchronizeYangResources(newModuleNameToContentMap));
+ schemaSetEntity.setYangResources(yangResourceEntities);
+ schemaSetRepository.save(schemaSetEntity);
+ }
+
+ private void updateAllModuleReferences(final Collection<ModuleReference> allModuleReferences,
+ final Integer schemaSetEntityId) {
+ yangResourceRepository.deleteSchemaSetYangResourceForSchemaSetId(schemaSetEntityId);
+ final List<Integer> allYangResourceIds =
+ yangResourceRepository.getResourceIdsByModuleReferences(allModuleReferences);
+ yangResourceRepository.insertSchemaSetIdYangResourceId(schemaSetEntityId, allYangResourceIds);
+ }
+
}