Internal Server Error when creating the same data node twice

[cps.git] / cps-ri / src / main / java / org / onap / cps / spi / impl / CpsModulePersistenceServiceImpl.java

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 (file)
new mode 100755 (executable)
index 3e3a4b4..9d3298e
--- 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
@@ -21,26 +21,33 @@
 package org.onap.cps.spi.impl;
 
 import com.google.common.collect.ImmutableSet;
+import java.nio.charset.StandardCharsets;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
 import javax.transaction.Transactional;
+import org.apache.commons.codec.digest.DigestUtils;
+import org.onap.cps.spi.CascadeDeleteAllowed;
+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.model.ModuleReference;
+import org.onap.cps.spi.entities.AnchorEntity;
+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.exceptions.AlreadyDefinedException;
+import org.onap.cps.spi.exceptions.SchemaSetInUseException;
+import org.onap.cps.spi.model.Anchor;
+import org.onap.cps.spi.repository.AnchorRepository;
 import org.onap.cps.spi.repository.DataspaceRepository;
+import org.onap.cps.spi.repository.FragmentRepository;
 import org.onap.cps.spi.repository.SchemaSetRepository;
 import org.onap.cps.spi.repository.YangResourceRepository;
-import org.onap.cps.yang.YangTextSchemaSourceSetBuilder;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.dao.DataIntegrityViolationException;
 import org.springframework.stereotype.Component;
-import org.springframework.util.DigestUtils;
+
 
 @Component
 public class CpsModulePersistenceServiceImpl implements CpsModulePersistenceService {
@@ -54,59 +61,95 @@ public class CpsModulePersistenceServiceImpl implements CpsModulePersistenceServ
     @Autowired
     private DataspaceRepository dataspaceRepository;
 
+    @Autowired
+    private AnchorRepository anchorRepository;
+
+    @Autowired
+    private FragmentRepository fragmentRepository;
+
+    @Autowired
+    private CpsAdminPersistenceService cpsAdminPersistenceService;
+
     @Override
     @Transactional
     public void storeSchemaSet(final String dataspaceName, final String schemaSetName,
         final Map<String, String> yangResourcesNameToContentMap) {
 
-        final Dataspace dataspace = dataspaceRepository.getByName(dataspaceName);
-        final Set<YangResource> yangResources = synchronizeYangResources(yangResourcesNameToContentMap);
-        final SchemaSet schemaSet = new SchemaSet();
-        schemaSet.setName(schemaSetName);
-        schemaSet.setDataspace(dataspace);
-        schemaSet.setYangResources(yangResources);
+        final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
+        final Set<YangResourceEntity> yangResourceEntities = synchronizeYangResources(yangResourcesNameToContentMap);
+        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<YangResource> synchronizeYangResources(final Map<String, String> yangResourcesNameToContentMap) {
-        final Map<String, YangResource> checksumToEntityMap = yangResourcesNameToContentMap.entrySet().stream()
+    private Set<YangResourceEntity> synchronizeYangResources(final Map<String, String> yangResourcesNameToContentMap) {
+        final Map<String, YangResourceEntity> checksumToEntityMap = yangResourcesNameToContentMap.entrySet().stream()
             .map(entry -> {
-                final YangResource yangResource = new YangResource();
-                yangResource.setName(entry.getKey());
-                yangResource.setContent(entry.getValue());
-                yangResource.setChecksum(DigestUtils.md5DigestAsHex(entry.getValue().getBytes()));
-                return yangResource;
+                final String checksum = DigestUtils.sha256Hex(entry.getValue().getBytes(StandardCharsets.UTF_8));
+                final YangResourceEntity yangResourceEntity = new YangResourceEntity();
+                yangResourceEntity.setName(entry.getKey());
+                yangResourceEntity.setContent(entry.getValue());
+                yangResourceEntity.setChecksum(checksum);
+                return yangResourceEntity;
             })
             .collect(Collectors.toMap(
-                YangResource::getChecksum,
+                YangResourceEntity::getChecksum,
                 entity -> entity
             ));
 
-        final List<YangResource> existingYangResources =
+        final List<YangResourceEntity> existingYangResourceEntities =
             yangResourceRepository.findAllByChecksumIn(checksumToEntityMap.keySet());
-        existingYangResources.forEach(yangFile -> checksumToEntityMap.remove(yangFile.getChecksum()));
+        existingYangResourceEntities.forEach(yangFile -> checksumToEntityMap.remove(yangFile.getChecksum()));
 
-        final Collection<YangResource> newYangResources = checksumToEntityMap.values();
-        if (!newYangResources.isEmpty()) {
-            yangResourceRepository.saveAll(newYangResources);
+        final Collection<YangResourceEntity> newYangResourceEntities = checksumToEntityMap.values();
+        if (!newYangResourceEntities.isEmpty()) {
+            yangResourceRepository.saveAll(newYangResourceEntities);
         }
 
-        return ImmutableSet.<YangResource>builder()
-            .addAll(existingYangResources)
-            .addAll(newYangResources)
+        return ImmutableSet.<YangResourceEntity>builder()
+            .addAll(existingYangResourceEntities)
+            .addAll(newYangResourceEntities)
             .build();
     }
 
     @Override
-    public Collection<ModuleReference> getModuleReferences(final String dataspaceName, final String schemaSetName) {
-        final Dataspace dataspace = dataspaceRepository.getByName(dataspaceName);
-        final SchemaSet schemaSet = schemaSetRepository.getByDataspaceAndName(dataspace, schemaSetName);
-        final Map<String, String> yangResourceNameToContent = schemaSet.getYangResources().stream().collect(
-            Collectors.toMap(YangResource::getName, YangResource::getContent));
-        return YangTextSchemaSourceSetBuilder.of(yangResourceNameToContent).getModuleReferences();
+    public Map<String, String> 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::getName, YangResourceEntity::getContent));
+    }
+
+    @Override
+    public Map<String, String> getYangSchemaSetResources(final String dataspaceName, final String anchorName) {
+        final Anchor anchor = cpsAdminPersistenceService.getAnchor(dataspaceName, anchorName);
+        return getYangSchemaResources(dataspaceName, anchor.getSchemaSetName());
+    }
+
+    @Override
+    @Transactional
+    public void deleteSchemaSet(final String dataspaceName, final String schemaSetName,
+        final CascadeDeleteAllowed cascadeDeleteAllowed) {
+        final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
+        final SchemaSetEntity schemaSetEntity =
+            schemaSetRepository.getByDataspaceAndName(dataspaceEntity, schemaSetName);
+
+        final Collection<AnchorEntity> anchorEntities = anchorRepository.findAllBySchemaSet(schemaSetEntity);
+        if (!anchorEntities.isEmpty()) {
+            if (cascadeDeleteAllowed != CascadeDeleteAllowed.CASCADE_DELETE_ALLOWED) {
+                throw new SchemaSetInUseException(dataspaceName, schemaSetName);
+            }
+            fragmentRepository.deleteByAnchorIn(anchorEntities);
+            anchorRepository.deleteAll(anchorEntities);
+        }
+        schemaSetRepository.delete(schemaSetEntity);
+        yangResourceRepository.deleteOrphans();
     }
 }