You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@atlas.apache.org by ap...@apache.org on 2018/05/08 18:59:18 UTC

atlas git commit: ATLAS-2659: IllegalStateException handling in Collection pipeline code

Repository: atlas
Updated Branches:
  refs/heads/master 9e3af41bf -> 5fed48d96


ATLAS-2659: IllegalStateException handling in Collection pipeline code

Change-Id: I01d983596ceb55b43e0d999a0e982ec006c9a246


Project: http://git-wip-us.apache.org/repos/asf/atlas/repo
Commit: http://git-wip-us.apache.org/repos/asf/atlas/commit/5fed48d9
Tree: http://git-wip-us.apache.org/repos/asf/atlas/tree/5fed48d9
Diff: http://git-wip-us.apache.org/repos/asf/atlas/diff/5fed48d9

Branch: refs/heads/master
Commit: 5fed48d969764ae72e8b87c204a2f481cb089716
Parents: 9e3af41
Author: apoorvnaik <ap...@apache.org>
Authored: Tue May 8 09:31:17 2018 -0700
Committer: apoorvnaik <ap...@apache.org>
Committed: Tue May 8 10:50:44 2018 -0700

----------------------------------------------------------------------
 .../atlas/glossary/GlossaryTermUtils.java       | 47 +++++++++++++++-----
 1 file changed, 35 insertions(+), 12 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/atlas/blob/5fed48d9/repository/src/main/java/org/apache/atlas/glossary/GlossaryTermUtils.java
----------------------------------------------------------------------
diff --git a/repository/src/main/java/org/apache/atlas/glossary/GlossaryTermUtils.java b/repository/src/main/java/org/apache/atlas/glossary/GlossaryTermUtils.java
index 95c0aa5..5400b77 100644
--- a/repository/src/main/java/org/apache/atlas/glossary/GlossaryTermUtils.java
+++ b/repository/src/main/java/org/apache/atlas/glossary/GlossaryTermUtils.java
@@ -33,11 +33,13 @@ import org.apache.atlas.type.AtlasRelationshipType;
 import org.apache.atlas.type.AtlasTypeRegistry;
 import org.apache.commons.collections.CollectionUtils;
 import org.apache.commons.collections.MapUtils;
+import org.apache.commons.lang.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
@@ -228,11 +230,18 @@ public class GlossaryTermUtils extends GlossaryUtils {
     }
 
     private Map<String, AtlasRelatedTermHeader> getRelatedTermHeaders(Map<AtlasGlossaryTerm.Relation, Set<AtlasRelatedTermHeader>> relatedTerms, AtlasGlossaryTerm.Relation relation) {
-        return Objects.nonNull(relatedTerms.get(relation)) ?
-                       relatedTerms.get(relation)
-                                   .stream()
-                                   .collect(Collectors.toMap(AtlasRelatedTermHeader::getTermGuid, t -> t)) :
-                       Collections.EMPTY_MAP;
+        if (Objects.nonNull(relatedTerms.get(relation))) {
+            Map<String, AtlasRelatedTermHeader> map = new HashMap<>();
+            for (AtlasRelatedTermHeader t : relatedTerms.get(relation)) {
+                AtlasRelatedTermHeader header = map.get(t.getTermGuid());
+                if (header == null || (StringUtils.isEmpty(header.getRelationGuid()) && StringUtils.isNotEmpty(t.getRelationGuid()))) {
+                    map.put(t.getTermGuid(), t);
+                }
+            }
+            return map;
+        } else {
+            return Collections.emptyMap();
+        }
     }
 
     private boolean updatedExistingTermRelation(Map<String, AtlasRelatedTermHeader> existingTermHeaders, AtlasRelatedTermHeader header) {
@@ -301,11 +310,18 @@ public class GlossaryTermUtils extends GlossaryUtils {
     }
 
     private Map<String, AtlasTermCategorizationHeader> getAssociatedCategories(final AtlasGlossaryTerm term) {
-        return Objects.nonNull(term.getCategories()) ?
-                       term.getCategories()
-                           .stream()
-                           .collect(Collectors.toMap(AtlasTermCategorizationHeader::getCategoryGuid, c -> c)) :
-                       Collections.EMPTY_MAP;
+        if (Objects.nonNull(term.getCategories())) {
+            Map<String, AtlasTermCategorizationHeader> map = new HashMap<>();
+            for (AtlasTermCategorizationHeader c : term.getCategories()) {
+                AtlasTermCategorizationHeader header = map.get(c.getCategoryGuid());
+                if (header == null || (StringUtils.isEmpty(header.getRelationGuid()) && StringUtils.isNotEmpty(c.getRelationGuid()))) {
+                    map.put(c.getCategoryGuid(), c);
+                }
+            }
+            return map;
+        } else {
+            return Collections.emptyMap();
+        }
     }
 
     private void createTermCategorizationRelationships(AtlasGlossaryTerm existing, Collection<AtlasTermCategorizationHeader> categories) throws AtlasBaseException {
@@ -354,12 +370,19 @@ public class GlossaryTermUtils extends GlossaryUtils {
         if (CollectionUtils.isNotEmpty(terms)) {
             Map<String, AtlasRelatedTermHeader> existingRelations;
             if (Objects.nonNull(existing.getRelatedTerms()) && Objects.nonNull(existing.getRelatedTerms().get(relation))) {
-                existingRelations = existing.getRelatedTerms().get(relation).stream().collect(Collectors.toMap(AtlasRelatedTermHeader::getTermGuid, t -> t));
+                Map<String, AtlasRelatedTermHeader> map = new HashMap<>();
+                for (AtlasRelatedTermHeader t : existing.getRelatedTerms().get(relation)) {
+                    AtlasRelatedTermHeader header = map.get(t.getTermGuid());
+                    if (header == null || (StringUtils.isEmpty(header.getRelationGuid()) && StringUtils.isNotEmpty(t.getRelationGuid()))) {
+                        map.put(t.getTermGuid(), t);
+                    }
+                }
+                existingRelations = map;
             } else {
                 existingRelations = Collections.emptyMap();
             }
             for (AtlasRelatedTermHeader term : terms) {
-                if (Objects.nonNull(existingRelations) && existingRelations.containsKey(term.getTermGuid())) {
+                if (existingRelations.containsKey(term.getTermGuid())) {
                     if (DEBUG_ENABLED) {
                         LOG.debug("Skipping existing term relation termGuid={}", term.getTermGuid());
                     }