atlas-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From suma...@apache.org
Subject incubator-atlas git commit: ATLAS-1657 Taxonomy term disassociation with assets fail
Date Wed, 08 Mar 2017 05:17:12 GMT
Repository: incubator-atlas
Updated Branches:
  refs/heads/master 0ed5e0aa5 -> d0f2ce5e9


ATLAS-1657 Taxonomy term disassociation with assets fail


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

Branch: refs/heads/master
Commit: d0f2ce5e9aa61b5fc8b3949d41cd2af902b39a12
Parents: 0ed5e0a
Author: Suma Shivaprasad <sumasai.shivaprasad@gmail.com>
Authored: Tue Mar 7 19:03:24 2017 -0800
Committer: Suma Shivaprasad <sumasai.shivaprasad@gmail.com>
Committed: Tue Mar 7 21:15:31 2017 -0800

----------------------------------------------------------------------
 .../apache/atlas/catalog/DefaultTypeSystem.java |  90 ++--
 .../org/apache/atlas/type/AtlasTypeUtil.java    |   7 +-
 .../converters/TypeConverterUtil.java           | 412 ++++++++++++++++++
 .../java/org/apache/atlas/util/RestUtils.java   | 421 -------------------
 .../atlas/web/resources/EntityService.java      |   6 +-
 .../atlas/web/resources/TaxonomyService.java    |   6 +-
 .../atlas/web/resources/TypesResource.java      |  14 +-
 .../org/apache/atlas/util/RestUtilsTest.java    |   6 +-
 .../web/resources/TaxonomyServiceTest.java      |  67 +--
 9 files changed, 531 insertions(+), 498 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/d0f2ce5e/catalog/src/main/java/org/apache/atlas/catalog/DefaultTypeSystem.java
----------------------------------------------------------------------
diff --git a/catalog/src/main/java/org/apache/atlas/catalog/DefaultTypeSystem.java b/catalog/src/main/java/org/apache/atlas/catalog/DefaultTypeSystem.java
index ea967f9..eabd272 100644
--- a/catalog/src/main/java/org/apache/atlas/catalog/DefaultTypeSystem.java
+++ b/catalog/src/main/java/org/apache/atlas/catalog/DefaultTypeSystem.java
@@ -20,33 +20,35 @@ package org.apache.atlas.catalog;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
+import org.apache.atlas.AtlasErrorCode;
 import org.apache.atlas.AtlasException;
 import org.apache.atlas.catalog.definition.ResourceDefinition;
 import org.apache.atlas.catalog.exception.CatalogRuntimeException;
 import org.apache.atlas.catalog.exception.ResourceAlreadyExistsException;
 import org.apache.atlas.catalog.exception.ResourceNotFoundException;
 import org.apache.atlas.classification.InterfaceAudience;
+import org.apache.atlas.exception.AtlasBaseException;
+import org.apache.atlas.model.typedef.AtlasClassificationDef;
+import org.apache.atlas.model.typedef.AtlasEntityDef;
+import org.apache.atlas.model.typedef.AtlasEnumDef;
+import org.apache.atlas.model.typedef.AtlasStructDef;
+import org.apache.atlas.model.typedef.AtlasTypesDef;
+import org.apache.atlas.repository.converters.TypeConverterUtil;
 import org.apache.atlas.services.MetadataService;
+import org.apache.atlas.store.AtlasTypeDefStore;
+import org.apache.atlas.type.AtlasTypeUtil;
 import org.apache.atlas.typesystem.ITypedReferenceableInstance;
 import org.apache.atlas.typesystem.Referenceable;
 import org.apache.atlas.typesystem.Struct;
-import org.apache.atlas.typesystem.TypesDef;
 import org.apache.atlas.typesystem.exception.EntityExistsException;
 import org.apache.atlas.typesystem.exception.EntityNotFoundException;
 import org.apache.atlas.typesystem.exception.TraitNotFoundException;
-import org.apache.atlas.typesystem.exception.TypeExistsException;
-import org.apache.atlas.typesystem.exception.TypeNotFoundException;
-import org.apache.atlas.typesystem.json.TypesSerialization;
 import org.apache.atlas.typesystem.types.AttributeDefinition;
 import org.apache.atlas.typesystem.types.ClassType;
-import org.apache.atlas.typesystem.types.DataTypes;
-import org.apache.atlas.typesystem.types.EnumTypeDefinition;
 import org.apache.atlas.typesystem.types.HierarchicalType;
-import org.apache.atlas.typesystem.types.HierarchicalTypeDefinition;
-import org.apache.atlas.typesystem.types.StructTypeDefinition;
 import org.apache.atlas.typesystem.types.TraitType;
-import org.apache.atlas.typesystem.types.utils.TypesUtil;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
@@ -58,36 +60,43 @@ import java.util.Map;
 public class DefaultTypeSystem implements AtlasTypeSystem {
     private final MetadataService metadataService;
 
+    private final AtlasTypeDefStore typeDefStore;
+
     /**
      * Constructor.
      *
      * @param metadataService  atlas metadata service
      */
-    public DefaultTypeSystem(MetadataService metadataService) throws AtlasException {
+    public DefaultTypeSystem(MetadataService metadataService, AtlasTypeDefStore typeDefStore) throws AtlasBaseException {
         this.metadataService = metadataService;
+        this.typeDefStore = typeDefStore;
         //Create namespace
         createSuperTypes();
     }
 
     @InterfaceAudience.Private
-    private void createSuperTypes() throws AtlasException {
-        HierarchicalTypeDefinition<TraitType> termType = TypesUtil
-            .createTraitTypeDef(TaxonomyResourceProvider.TAXONOMY_TERM_TYPE, ImmutableSet.<String>of(),
-                TypesUtil.createOptionalAttrDef(TaxonomyResourceProvider.NAMESPACE_ATTRIBUTE_NAME,
-                    DataTypes.STRING_TYPE));
+    private void createSuperTypes() throws AtlasBaseException {
+
+        AtlasClassificationDef termClassification = AtlasTypeUtil.createTraitTypeDef(TaxonomyResourceProvider.TAXONOMY_TERM_TYPE, TaxonomyResourceProvider.TAXONOMY_TERM_TYPE,
+            ImmutableSet.<String>of(), AtlasTypeUtil.createOptionalAttrDef(TaxonomyResourceProvider.NAMESPACE_ATTRIBUTE_NAME, "string"));
 
-        createTraitType(termType);
+        createTraitType(termClassification);
     }
 
-    private void createTraitType(HierarchicalTypeDefinition<TraitType> type) throws AtlasException {
+    private void createTraitType(AtlasClassificationDef classificationDef) throws AtlasBaseException {
         try {
-            metadataService.getTypeDefinition(type.typeName);
-        } catch(TypeNotFoundException tne) {
+            typeDefStore.getClassificationDefByName(classificationDef.getName());
+        } catch (AtlasBaseException tne) {
             //Type not found . Create
-            TypesDef typesDef = TypesUtil.getTypesDef(ImmutableList.<EnumTypeDefinition>of(), ImmutableList.<StructTypeDefinition>of(),
-                ImmutableList.of(type),
-                ImmutableList.<HierarchicalTypeDefinition<ClassType>>of());
-            metadataService.createType(TypesSerialization.toJson(typesDef));
+            if (tne.getAtlasErrorCode() == AtlasErrorCode.TYPE_NAME_NOT_FOUND) {
+                AtlasTypesDef typesDef = new AtlasTypesDef(ImmutableList.<AtlasEnumDef>of(), ImmutableList.<AtlasStructDef>of(),
+                    ImmutableList.of(classificationDef),
+                    ImmutableList.<AtlasEntityDef>of());
+
+                typeDefStore.createTypesDef(typesDef);
+            } else {
+                throw tne;
+            }
         }
     }
 
@@ -194,24 +203,37 @@ public class DefaultTypeSystem implements AtlasTypeSystem {
                                                          String name,
                                                          String description,
                                                          boolean isTrait)
-                                                         throws ResourceAlreadyExistsException {
+        throws ResourceAlreadyExistsException {
 
         try {
-            HierarchicalTypeDefinition<T> definition = null;
+            List<AtlasStructDef.AtlasAttributeDef> attrDefs  = new ArrayList<>();
+            for (AttributeDefinition attrDefinition : attributes) {
+                attrDefs.add(TypeConverterUtil.toAtlasAttributeDef(attrDefinition));
+            }
             if ( isTrait) {
-                definition = new HierarchicalTypeDefinition<>(type, name, description,
-                        ImmutableSet.of(TaxonomyResourceProvider.TAXONOMY_TERM_TYPE), attributes.toArray(new AttributeDefinition[attributes.size()]));
+                AtlasClassificationDef classificationDef = new AtlasClassificationDef(name, description, "1.0", attrDefs, ImmutableSet.of(TaxonomyResourceProvider.TAXONOMY_TERM_TYPE));
+                AtlasTypesDef typesDef = new AtlasTypesDef(ImmutableList.<AtlasEnumDef>of(), ImmutableList.<AtlasStructDef>of(),
+                    ImmutableList.of(classificationDef),
+                    ImmutableList.<AtlasEntityDef>of());
+
+                typeDefStore.createTypesDef(typesDef);
+
             } else {
-                definition = new HierarchicalTypeDefinition<>(type, name, description,
-                        ImmutableSet.<String>of(), attributes.toArray(new AttributeDefinition[attributes.size()]));
+                AtlasEntityDef entityDef = new AtlasEntityDef(name, description, "1.0", attrDefs);
+                AtlasTypesDef typesDef = new AtlasTypesDef(ImmutableList.<AtlasEnumDef>of(), ImmutableList.<AtlasStructDef>of(),
+                    ImmutableList.<AtlasClassificationDef>of(),
+                    ImmutableList.of(entityDef));
+
+                typeDefStore.createTypesDef(typesDef);
             }
 
-            metadataService.createType(TypesSerialization.toJson(definition, isTrait));
-        } catch (TypeExistsException e) {
-            throw new ResourceAlreadyExistsException(String.format("Type '%s' already exists", name));
-        } catch (AtlasException e) {
-            throw new CatalogRuntimeException(String.format(
+        } catch (AtlasBaseException e) {
+            if ( e.getAtlasErrorCode() == AtlasErrorCode.TYPE_ALREADY_EXISTS) {
+                throw new ResourceAlreadyExistsException(String.format("Type '%s' already exists", name));
+            } else {
+                throw new CatalogRuntimeException(String.format(
                     "Unable to create type '%s' in type system: %s", name, e), e);
+            }
         }
     }
 }

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/d0f2ce5e/intg/src/main/java/org/apache/atlas/type/AtlasTypeUtil.java
----------------------------------------------------------------------
diff --git a/intg/src/main/java/org/apache/atlas/type/AtlasTypeUtil.java b/intg/src/main/java/org/apache/atlas/type/AtlasTypeUtil.java
index 6d3a9f5..eca1abf 100644
--- a/intg/src/main/java/org/apache/atlas/type/AtlasTypeUtil.java
+++ b/intg/src/main/java/org/apache/atlas/type/AtlasTypeUtil.java
@@ -121,10 +121,11 @@ public class AtlasTypeUtil {
     }
 
     public static void validateType(AtlasBaseTypeDef typeDef) throws AtlasBaseException {
-        String typeName = typeDef.getName();
+        boolean isValidName = (typeDef instanceof AtlasClassificationDef) ? isValidTraitTypeName(typeDef.getName())
+            : isValidTypeName(typeDef.getName());
 
-        if (!isValidTypeName(typeName)) {
-            throw new AtlasBaseException(AtlasErrorCode.TYPE_NAME_INVALID_FORMAT, typeName, typeDef.getCategory().name());
+        if (!isValidName) {
+            throw new AtlasBaseException(AtlasErrorCode.TYPE_NAME_INVALID_FORMAT, typeDef.getName(), typeDef.getCategory().name());
         }
     }
 

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/d0f2ce5e/repository/src/main/java/org/apache/atlas/repository/converters/TypeConverterUtil.java
----------------------------------------------------------------------
diff --git a/repository/src/main/java/org/apache/atlas/repository/converters/TypeConverterUtil.java b/repository/src/main/java/org/apache/atlas/repository/converters/TypeConverterUtil.java
new file mode 100644
index 0000000..7902100
--- /dev/null
+++ b/repository/src/main/java/org/apache/atlas/repository/converters/TypeConverterUtil.java
@@ -0,0 +1,412 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * 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.
+ */
+
+package org.apache.atlas.repository.converters;
+
+import static org.apache.atlas.AtlasErrorCode.INVALID_TYPE_DEFINITION;
+import static org.apache.atlas.model.typedef.AtlasStructDef.AtlasConstraintDef.CONSTRAINT_TYPE_OWNED_REF;
+import static org.apache.atlas.model.typedef.AtlasStructDef.AtlasConstraintDef.CONSTRAINT_TYPE_INVERSE_REF;
+import static org.apache.atlas.model.typedef.AtlasStructDef.AtlasConstraintDef.CONSTRAINT_PARAM_ATTRIBUTE;
+import static org.apache.atlas.type.AtlasTypeUtil.isArrayType;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Set;
+
+import org.apache.atlas.exception.AtlasBaseException;
+import org.apache.atlas.model.typedef.AtlasClassificationDef;
+import org.apache.atlas.model.typedef.AtlasEntityDef;
+import org.apache.atlas.model.typedef.AtlasEnumDef;
+import org.apache.atlas.model.typedef.AtlasEnumDef.AtlasEnumElementDef;
+import org.apache.atlas.model.typedef.AtlasStructDef;
+import org.apache.atlas.model.typedef.AtlasStructDef.AtlasAttributeDef;
+import org.apache.atlas.model.typedef.AtlasStructDef.AtlasAttributeDef.Cardinality;
+import org.apache.atlas.model.typedef.AtlasStructDef.AtlasConstraintDef;
+import org.apache.atlas.model.typedef.AtlasTypeDefHeader;
+import org.apache.atlas.model.typedef.AtlasTypesDef;
+import org.apache.atlas.repository.store.graph.v1.AtlasStructDefStoreV1;
+import org.apache.atlas.type.AtlasClassificationType;
+import org.apache.atlas.type.AtlasEntityType;
+import org.apache.atlas.type.AtlasEnumType;
+import org.apache.atlas.type.AtlasStructType;
+import org.apache.atlas.type.AtlasStructType.AtlasAttribute;
+import org.apache.atlas.type.AtlasType;
+import org.apache.atlas.type.AtlasTypeRegistry;
+import org.apache.atlas.type.AtlasTypeUtil;
+import org.apache.atlas.typesystem.TypesDef;
+import org.apache.atlas.typesystem.json.TypesSerialization;
+import org.apache.atlas.typesystem.types.AttributeDefinition;
+import org.apache.atlas.typesystem.types.ClassType;
+import org.apache.atlas.typesystem.types.EnumTypeDefinition;
+import org.apache.atlas.typesystem.types.EnumValue;
+import org.apache.atlas.typesystem.types.HierarchicalTypeDefinition;
+import org.apache.atlas.typesystem.types.Multiplicity;
+import org.apache.atlas.typesystem.types.StructTypeDefinition;
+import org.apache.atlas.typesystem.types.TraitType;
+import org.apache.atlas.typesystem.types.utils.TypesUtil;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+
+
+public final class TypeConverterUtil {
+    private TypeConverterUtil() {}
+    private static final Logger LOG = LoggerFactory.getLogger(TypeConverterUtil.class);
+
+    public static TypesDef toTypesDef(AtlasType type, AtlasTypeRegistry typeRegistry) throws AtlasBaseException {
+        final TypesDef ret;
+
+        if (type instanceof AtlasEnumType) {
+            ret = TypeConverterUtil.enumToTypesDef((AtlasEnumType) type);
+        } else if (type instanceof AtlasEntityType) {
+            ret = TypeConverterUtil.entityToTypesDef((AtlasEntityType) type, typeRegistry);
+        } else if (type instanceof AtlasClassificationType) {
+            ret = TypeConverterUtil.classificationToTypesDef((AtlasClassificationType) type, typeRegistry);
+        } else if (type instanceof AtlasStructType) {
+            ret = TypeConverterUtil.structToTypesDef((AtlasStructType) type, typeRegistry);
+        } else {
+            ret = new TypesDef();
+        }
+
+        return ret;
+    }
+
+    private static TypesDef enumToTypesDef(AtlasEnumType enumType) {
+        TypesDef ret = null;
+
+        AtlasEnumDef enumDef = enumType.getEnumDef();
+
+        String      enumName    = enumDef.getName();
+        String      enumDesc    = enumDef.getDescription();
+        String      enumVersion = enumDef.getTypeVersion();
+        EnumValue[] enumValues  = getEnumValues(enumDef.getElementDefs());
+
+        if (enumName != null && enumValues != null && enumValues.length > 0) {
+            EnumTypeDefinition enumTypeDef = new EnumTypeDefinition(enumName, enumDesc, enumVersion, enumValues);
+
+            ret = TypesUtil.getTypesDef(ImmutableList.of(enumTypeDef),
+                                        ImmutableList.<StructTypeDefinition>of(),
+                                        ImmutableList.<HierarchicalTypeDefinition<TraitType>>of(),
+                                        ImmutableList.<HierarchicalTypeDefinition<ClassType>>of());
+        }
+
+        return ret;
+    }
+
+    private static TypesDef structToTypesDef(AtlasStructType structType, AtlasTypeRegistry registry)
+                                                                                            throws AtlasBaseException {
+        String                typeName      = structType.getStructDef().getName();
+        String                typeDesc      = structType.getStructDef().getDescription();
+        String                typeVersion   = structType.getStructDef().getTypeVersion();
+        AttributeDefinition[] attributes    = getAttributes(structType, registry);
+        StructTypeDefinition  structTypeDef = TypesUtil.createStructTypeDef(typeName, typeDesc, typeVersion, attributes);
+
+        TypesDef ret = TypesUtil.getTypesDef(ImmutableList.<EnumTypeDefinition>of(),
+                                             ImmutableList.of(structTypeDef),
+                                             ImmutableList.<HierarchicalTypeDefinition<TraitType>>of(),
+                                             ImmutableList.<HierarchicalTypeDefinition<ClassType>>of());
+
+        return ret;
+    }
+
+    private static TypesDef entityToTypesDef(AtlasEntityType entityType, AtlasTypeRegistry registry)
+                                                                                             throws AtlasBaseException {
+        String                typeName    = entityType.getEntityDef().getName();
+        String                typeDesc    = entityType.getEntityDef().getDescription();
+        String                typeVersion = entityType.getEntityDef().getTypeVersion();
+        ImmutableSet          superTypes  = ImmutableSet.copyOf(entityType.getEntityDef().getSuperTypes());
+        AttributeDefinition[] attributes  = getAttributes(entityType, registry);
+
+        HierarchicalTypeDefinition<ClassType> classType = TypesUtil.createClassTypeDef(typeName, typeDesc, typeVersion,
+                                                                                       superTypes, attributes);
+        TypesDef ret = TypesUtil.getTypesDef(ImmutableList.<EnumTypeDefinition>of(),
+                                             ImmutableList.<StructTypeDefinition>of(),
+                                             ImmutableList.<HierarchicalTypeDefinition<TraitType>>of(),
+                                             ImmutableList.of(classType));
+
+        return ret;
+    }
+
+    private static TypesDef classificationToTypesDef(AtlasClassificationType classificationType,
+                                                     AtlasTypeRegistry registry) throws AtlasBaseException {
+        String                typeName    = classificationType.getClassificationDef().getName();
+        String                typeDesc    = classificationType.getClassificationDef().getDescription();
+        String                typeVersion = classificationType.getClassificationDef().getTypeVersion();
+        ImmutableSet          superTypes  = ImmutableSet.copyOf(classificationType.getClassificationDef().getSuperTypes());
+        AttributeDefinition[] attributes  = getAttributes(classificationType, registry);
+
+        HierarchicalTypeDefinition traitType = TypesUtil.createTraitTypeDef(typeName, typeDesc, typeVersion, superTypes,
+                                                                             attributes);
+        TypesDef ret = TypesUtil.getTypesDef(ImmutableList.<EnumTypeDefinition>of(),
+                                             ImmutableList.<StructTypeDefinition>of(),
+                                             ImmutableList.<HierarchicalTypeDefinition<TraitType>>of(traitType),
+                                             ImmutableList.<HierarchicalTypeDefinition<ClassType>>of());
+        return ret;
+    }
+
+
+
+    public static AtlasTypesDef toAtlasTypesDef(String typeDefinition, AtlasTypeRegistry registry) throws AtlasBaseException {
+        AtlasTypesDef ret = new AtlasTypesDef();
+
+        try {
+            if (StringUtils.isEmpty(typeDefinition)) {
+                throw new AtlasBaseException(INVALID_TYPE_DEFINITION, typeDefinition);
+            }
+
+            TypesDef typesDef = TypesSerialization.fromJson(typeDefinition);
+            if (CollectionUtils.isNotEmpty(typesDef.enumTypesAsJavaList())) {
+                List<AtlasEnumDef> enumDefs = toAtlasEnumDefs(typesDef.enumTypesAsJavaList());
+                ret.setEnumDefs(enumDefs);
+            }
+
+            if (CollectionUtils.isNotEmpty(typesDef.structTypesAsJavaList())) {
+                List<AtlasStructDef> structDefs = toAtlasStructDefs(typesDef.structTypesAsJavaList());
+                ret.setStructDefs(structDefs);
+            }
+
+            if (CollectionUtils.isNotEmpty(typesDef.classTypesAsJavaList())) {
+                List<AtlasEntityDef> entityDefs = toAtlasEntityDefs(typesDef.classTypesAsJavaList(), registry);
+                ret.setEntityDefs(entityDefs);
+            }
+
+            if (CollectionUtils.isNotEmpty(typesDef.traitTypesAsJavaList())) {
+                List<AtlasClassificationDef> classificationDefs = toAtlasClassificationDefs(typesDef.traitTypesAsJavaList());
+                ret.setClassificationDefs(classificationDefs);
+            }
+
+        } catch (Exception e) {
+            LOG.error("Invalid type definition = {}", typeDefinition, e);
+            throw new AtlasBaseException(INVALID_TYPE_DEFINITION, typeDefinition);
+        }
+
+        return ret;
+    }
+
+    public static ImmutableList<String> getTypeNames(List<AtlasTypeDefHeader> atlasTypesDefs) {
+        List<String> ret = new ArrayList<String>();
+        if (CollectionUtils.isNotEmpty(atlasTypesDefs)) {
+            for (AtlasTypeDefHeader atlasTypesDef : atlasTypesDefs) {
+                ret.add(atlasTypesDef.getName());
+            }
+        }
+
+        return ImmutableList.copyOf(ret);
+    }
+
+    public static List<String> getTypeNames(AtlasTypesDef typesDef) {
+        List<AtlasTypeDefHeader> atlasTypesDefs = AtlasTypeUtil.toTypeDefHeader(typesDef);
+        return getTypeNames(atlasTypesDefs);
+    }
+
+    private static List<AtlasEnumDef> toAtlasEnumDefs(List<EnumTypeDefinition> enumTypeDefinitions) {
+        List<AtlasEnumDef> ret = new ArrayList<AtlasEnumDef>();
+
+        for (EnumTypeDefinition enumType : enumTypeDefinitions) {
+            AtlasEnumDef enumDef = new AtlasEnumDef();
+            enumDef.setName(enumType.name);
+            enumDef.setDescription(enumType.description);
+            enumDef.setTypeVersion(enumType.version);
+            enumDef.setElementDefs(getAtlasEnumElementDefs(enumType.enumValues));
+
+            ret.add(enumDef);
+        }
+
+        return ret;
+    }
+
+    private static List<AtlasStructDef> toAtlasStructDefs(List<StructTypeDefinition> structTypeDefinitions)
+            throws AtlasBaseException {
+        List<AtlasStructDef> ret = new ArrayList<AtlasStructDef>();
+
+        for (StructTypeDefinition structType : structTypeDefinitions) {
+            AtlasStructDef          structDef = new AtlasStructDef();
+            List<AtlasAttributeDef> attrDefs  = new ArrayList<AtlasAttributeDef>();
+
+            structDef.setName(structType.typeName);
+            structDef.setDescription(structType.typeDescription);
+            structDef.setTypeVersion(structType.typeVersion);
+
+            AttributeDefinition[] attrDefinitions = structType.attributeDefinitions;
+            for (AttributeDefinition attrDefinition : attrDefinitions) {
+                attrDefs.add(toAtlasAttributeDef(attrDefinition));
+            }
+
+            structDef.setAttributeDefs(attrDefs);
+            ret.add(structDef);
+        }
+
+        return ret;
+    }
+
+    private static List<AtlasClassificationDef> toAtlasClassificationDefs(List<HierarchicalTypeDefinition<TraitType>> traitTypeDefinitions)
+            throws AtlasBaseException {
+        List<AtlasClassificationDef> ret = new ArrayList<AtlasClassificationDef>();
+
+        for (HierarchicalTypeDefinition<TraitType> traitType : traitTypeDefinitions) {
+            AtlasClassificationDef  classifDef = new AtlasClassificationDef();
+            List<AtlasAttributeDef> attrDefs   = new ArrayList<AtlasAttributeDef>();
+
+            classifDef.setName(traitType.typeName);
+            classifDef.setDescription(traitType.typeDescription);
+            classifDef.setTypeVersion(traitType.typeVersion);
+            classifDef.setSuperTypes(traitType.superTypes);
+
+            AttributeDefinition[] attrDefinitions = traitType.attributeDefinitions;
+            for (AttributeDefinition attrDefinition : attrDefinitions) {
+                attrDefs.add(toAtlasAttributeDef(attrDefinition));
+            }
+
+            classifDef.setAttributeDefs(attrDefs);
+            ret.add(classifDef);
+        }
+
+        return ret;
+    }
+
+    private static List<AtlasEntityDef> toAtlasEntityDefs(List<HierarchicalTypeDefinition<ClassType>> classTypeDefinitions,
+                                                          AtlasTypeRegistry registry) throws AtlasBaseException {
+        List<AtlasEntityDef> atlasEntityDefs = new ArrayList<AtlasEntityDef>();
+
+        for (HierarchicalTypeDefinition<ClassType> classType : classTypeDefinitions) {
+            List<AtlasAttributeDef> attrDefs         = new ArrayList<AtlasAttributeDef>();
+            AtlasEntityDef          atlasEntityDef   = new AtlasEntityDef();
+            String                  classTypeDefName = classType.typeName;
+
+            atlasEntityDef.setName(classTypeDefName);
+            atlasEntityDef.setDescription(classType.typeDescription);
+            atlasEntityDef.setTypeVersion(classType.typeVersion);
+            atlasEntityDef.setSuperTypes(classType.superTypes);
+
+            AttributeDefinition[] attrDefinitions = classType.attributeDefinitions;
+            for (AttributeDefinition oldAttr : attrDefinitions) {
+                AtlasAttributeDef newAttr = toAtlasAttributeDef(oldAttr);
+                attrDefs.add(newAttr);
+            }
+
+            atlasEntityDef.setAttributeDefs(attrDefs);
+            atlasEntityDefs.add(atlasEntityDef);
+        }
+
+        return atlasEntityDefs;
+    }
+
+    private static String getArrayTypeName(String attrType) {
+        String ret = null;
+        if (isArrayType(attrType)) {
+            Set<String> typeNames = AtlasTypeUtil.getReferencedTypeNames(attrType);
+            if (typeNames.size() > 0) {
+                ret = typeNames.iterator().next();
+            }
+        }
+
+        return ret;
+    }
+
+    private static List<AtlasEnumElementDef> getAtlasEnumElementDefs(EnumValue[] enums) {
+        List<AtlasEnumElementDef> ret = new ArrayList<AtlasEnumElementDef>();
+
+        for (EnumValue enumElem : enums) {
+            ret.add(new AtlasEnumElementDef(enumElem.value, null, enumElem.ordinal));
+        }
+
+        return ret;
+    }
+
+    private static EnumValue[] getEnumValues(List<AtlasEnumElementDef> enumDefs) {
+        List<EnumValue> ret = new ArrayList<EnumValue>();
+
+        if (CollectionUtils.isNotEmpty(enumDefs)) {
+            for (AtlasEnumElementDef enumDef : enumDefs) {
+                if (enumDef != null) {
+                    ret.add(new EnumValue(enumDef.getValue(), enumDef.getOrdinal()));
+                }
+            }
+        }
+
+        return ret.toArray(new EnumValue[ret.size()]);
+    }
+
+    public static AtlasAttributeDef toAtlasAttributeDef(final AttributeDefinition attrDefinition) {
+        AtlasAttributeDef ret = new AtlasAttributeDef();
+
+        ret.setName(attrDefinition.name);
+        ret.setTypeName(attrDefinition.dataTypeName);
+        ret.setIsIndexable(attrDefinition.isIndexable);
+        ret.setIsUnique(attrDefinition.isUnique);
+        if (attrDefinition.isComposite) {
+            ret.addConstraint(new AtlasConstraintDef(CONSTRAINT_TYPE_OWNED_REF));
+        }
+
+        if (StringUtils.isNotBlank(attrDefinition.reverseAttributeName)) {
+            ret.addConstraint(new AtlasConstraintDef(CONSTRAINT_TYPE_INVERSE_REF,
+                                       new HashMap<String, Object>() {{
+                                           put(CONSTRAINT_PARAM_ATTRIBUTE, attrDefinition.reverseAttributeName);
+                                       }}));
+        }
+
+        // Multiplicity attribute mapping
+        Multiplicity multiplicity = attrDefinition.multiplicity;
+        int          minCount     = multiplicity.lower;
+        int          maxCount     = multiplicity.upper;
+        boolean      isUnique     = multiplicity.isUnique;
+
+        if (minCount == 0) {
+            ret.setIsOptional(true);
+            ret.setValuesMinCount(0);
+        } else {
+            ret.setIsOptional(false);
+            ret.setValuesMinCount(minCount);
+        }
+
+        if (maxCount < 2) {
+            ret.setCardinality(Cardinality.SINGLE);
+            ret.setValuesMaxCount(1);
+        } else {
+            if (!isUnique) {
+                ret.setCardinality(Cardinality.LIST);
+            } else {
+                ret.setCardinality(Cardinality.SET);
+            }
+
+            ret.setValuesMaxCount(maxCount);
+        }
+
+        return ret;
+    }
+
+    private static AttributeDefinition[] getAttributes(AtlasStructType structType, AtlasTypeRegistry registry) throws AtlasBaseException {
+        List<AttributeDefinition> ret      = new ArrayList<>();
+        List<AtlasAttributeDef>   attrDefs = structType.getStructDef().getAttributeDefs();
+
+        if (CollectionUtils.isNotEmpty(attrDefs)) {
+            for (AtlasAttributeDef attrDef : attrDefs) {
+                AtlasAttribute attribute = structType.getAttribute(attrDef.getName());
+
+                ret.add(AtlasStructDefStoreV1.toAttributeDefintion(attribute));
+            }
+        }
+
+        return ret.toArray(new AttributeDefinition[ret.size()]);
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/d0f2ce5e/webapp/src/main/java/org/apache/atlas/util/RestUtils.java
----------------------------------------------------------------------
diff --git a/webapp/src/main/java/org/apache/atlas/util/RestUtils.java b/webapp/src/main/java/org/apache/atlas/util/RestUtils.java
deleted file mode 100644
index 6ce1bba..0000000
--- a/webapp/src/main/java/org/apache/atlas/util/RestUtils.java
+++ /dev/null
@@ -1,421 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you 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
- * <p>
- * http://www.apache.org/licenses/LICENSE-2.0
- * <p>
- * 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.
- */
-
-package org.apache.atlas.util;
-
-import static org.apache.atlas.AtlasErrorCode.INVALID_TYPE_DEFINITION;
-import static org.apache.atlas.model.typedef.AtlasStructDef.AtlasConstraintDef.CONSTRAINT_TYPE_OWNED_REF;
-import static org.apache.atlas.model.typedef.AtlasStructDef.AtlasConstraintDef.CONSTRAINT_TYPE_INVERSE_REF;
-import static org.apache.atlas.model.typedef.AtlasStructDef.AtlasConstraintDef.CONSTRAINT_PARAM_ATTRIBUTE;
-import static org.apache.atlas.type.AtlasTypeUtil.isArrayType;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Set;
-
-import org.apache.atlas.exception.AtlasBaseException;
-import org.apache.atlas.model.TypeCategory;
-import org.apache.atlas.model.typedef.AtlasClassificationDef;
-import org.apache.atlas.model.typedef.AtlasEntityDef;
-import org.apache.atlas.model.typedef.AtlasEnumDef;
-import org.apache.atlas.model.typedef.AtlasEnumDef.AtlasEnumElementDef;
-import org.apache.atlas.model.typedef.AtlasStructDef;
-import org.apache.atlas.model.typedef.AtlasStructDef.AtlasAttributeDef;
-import org.apache.atlas.model.typedef.AtlasStructDef.AtlasAttributeDef.Cardinality;
-import org.apache.atlas.model.typedef.AtlasStructDef.AtlasConstraintDef;
-import org.apache.atlas.model.typedef.AtlasTypeDefHeader;
-import org.apache.atlas.model.typedef.AtlasTypesDef;
-import org.apache.atlas.repository.store.graph.v1.AtlasStructDefStoreV1;
-import org.apache.atlas.type.AtlasClassificationType;
-import org.apache.atlas.type.AtlasEntityType;
-import org.apache.atlas.type.AtlasEnumType;
-import org.apache.atlas.type.AtlasStructType;
-import org.apache.atlas.type.AtlasStructType.AtlasAttribute;
-import org.apache.atlas.type.AtlasType;
-import org.apache.atlas.type.AtlasTypeRegistry;
-import org.apache.atlas.type.AtlasTypeUtil;
-import org.apache.atlas.typesystem.TypesDef;
-import org.apache.atlas.typesystem.json.TypesSerialization;
-import org.apache.atlas.typesystem.types.AttributeDefinition;
-import org.apache.atlas.typesystem.types.ClassType;
-import org.apache.atlas.typesystem.types.EnumTypeDefinition;
-import org.apache.atlas.typesystem.types.EnumValue;
-import org.apache.atlas.typesystem.types.HierarchicalTypeDefinition;
-import org.apache.atlas.typesystem.types.Multiplicity;
-import org.apache.atlas.typesystem.types.StructTypeDefinition;
-import org.apache.atlas.typesystem.types.TraitType;
-import org.apache.atlas.typesystem.types.utils.TypesUtil;
-import org.apache.commons.collections.CollectionUtils;
-import org.apache.commons.lang.StringUtils;
-import org.codehaus.jackson.map.ObjectMapper;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Set;
-
-import static org.apache.atlas.AtlasErrorCode.INVALID_TYPE_DEFINITION;
-import static org.apache.atlas.type.AtlasTypeUtil.isArrayType;
-
-
-public final class RestUtils {
-    private RestUtils() {}
-    private static final Logger LOG = LoggerFactory.getLogger(RestUtils.class);
-
-    public static TypesDef toTypesDef(AtlasType type, AtlasTypeRegistry typeRegistry) throws AtlasBaseException {
-        final TypesDef ret;
-
-        if (type instanceof AtlasEnumType) {
-            ret = RestUtils.enumToTypesDef((AtlasEnumType)type);
-        } else if (type instanceof AtlasEntityType) {
-            ret = RestUtils.entityToTypesDef((AtlasEntityType)type, typeRegistry);
-        } else if (type instanceof AtlasClassificationType) {
-            ret = RestUtils.classificationToTypesDef((AtlasClassificationType)type, typeRegistry);
-        } else if (type instanceof AtlasStructType) {
-            ret = RestUtils.structToTypesDef((AtlasStructType)type, typeRegistry);
-        } else {
-            ret = new TypesDef();
-        }
-
-        return ret;
-    }
-
-    private static TypesDef enumToTypesDef(AtlasEnumType enumType) {
-        TypesDef ret = null;
-
-        AtlasEnumDef enumDef = enumType.getEnumDef();
-
-        String      enumName    = enumDef.getName();
-        String      enumDesc    = enumDef.getDescription();
-        String      enumVersion = enumDef.getTypeVersion();
-        EnumValue[] enumValues  = getEnumValues(enumDef.getElementDefs());
-
-        if (enumName != null && enumValues != null && enumValues.length > 0) {
-            EnumTypeDefinition enumTypeDef = new EnumTypeDefinition(enumName, enumDesc, enumVersion, enumValues);
-
-            ret = TypesUtil.getTypesDef(ImmutableList.of(enumTypeDef),
-                                        ImmutableList.<StructTypeDefinition>of(),
-                                        ImmutableList.<HierarchicalTypeDefinition<TraitType>>of(),
-                                        ImmutableList.<HierarchicalTypeDefinition<ClassType>>of());
-        }
-
-        return ret;
-    }
-
-    private static TypesDef structToTypesDef(AtlasStructType structType, AtlasTypeRegistry registry)
-                                                                                            throws AtlasBaseException {
-        String                typeName      = structType.getStructDef().getName();
-        String                typeDesc      = structType.getStructDef().getDescription();
-        String                typeVersion   = structType.getStructDef().getTypeVersion();
-        AttributeDefinition[] attributes    = getAttributes(structType, registry);
-        StructTypeDefinition  structTypeDef = TypesUtil.createStructTypeDef(typeName, typeDesc, typeVersion, attributes);
-
-        TypesDef ret = TypesUtil.getTypesDef(ImmutableList.<EnumTypeDefinition>of(),
-                                             ImmutableList.of(structTypeDef),
-                                             ImmutableList.<HierarchicalTypeDefinition<TraitType>>of(),
-                                             ImmutableList.<HierarchicalTypeDefinition<ClassType>>of());
-
-        return ret;
-    }
-
-    private static TypesDef entityToTypesDef(AtlasEntityType entityType, AtlasTypeRegistry registry)
-                                                                                             throws AtlasBaseException {
-        String                typeName    = entityType.getEntityDef().getName();
-        String                typeDesc    = entityType.getEntityDef().getDescription();
-        String                typeVersion = entityType.getEntityDef().getTypeVersion();
-        ImmutableSet          superTypes  = ImmutableSet.copyOf(entityType.getEntityDef().getSuperTypes());
-        AttributeDefinition[] attributes  = getAttributes(entityType, registry);
-
-        HierarchicalTypeDefinition<ClassType> classType = TypesUtil.createClassTypeDef(typeName, typeDesc, typeVersion,
-                                                                                       superTypes, attributes);
-        TypesDef ret = TypesUtil.getTypesDef(ImmutableList.<EnumTypeDefinition>of(),
-                                             ImmutableList.<StructTypeDefinition>of(),
-                                             ImmutableList.<HierarchicalTypeDefinition<TraitType>>of(),
-                                             ImmutableList.of(classType));
-
-        return ret;
-    }
-
-    private static TypesDef classificationToTypesDef(AtlasClassificationType classificationType,
-                                                     AtlasTypeRegistry registry) throws AtlasBaseException {
-        String                typeName    = classificationType.getClassificationDef().getName();
-        String                typeDesc    = classificationType.getClassificationDef().getDescription();
-        String                typeVersion = classificationType.getClassificationDef().getTypeVersion();
-        ImmutableSet          superTypes  = ImmutableSet.copyOf(classificationType.getClassificationDef().getSuperTypes());
-        AttributeDefinition[] attributes  = getAttributes(classificationType, registry);
-
-        HierarchicalTypeDefinition traitType = TypesUtil.createTraitTypeDef(typeName, typeDesc, typeVersion, superTypes,
-                                                                             attributes);
-        TypesDef ret = TypesUtil.getTypesDef(ImmutableList.<EnumTypeDefinition>of(),
-                                             ImmutableList.<StructTypeDefinition>of(),
-                                             ImmutableList.<HierarchicalTypeDefinition<TraitType>>of(traitType),
-                                             ImmutableList.<HierarchicalTypeDefinition<ClassType>>of());
-        return ret;
-    }
-
-
-
-    public static AtlasTypesDef toAtlasTypesDef(String typeDefinition, AtlasTypeRegistry registry) throws AtlasBaseException {
-        AtlasTypesDef ret = new AtlasTypesDef();
-
-        try {
-            if (StringUtils.isEmpty(typeDefinition)) {
-                throw new AtlasBaseException(INVALID_TYPE_DEFINITION, typeDefinition);
-            }
-
-            TypesDef typesDef = TypesSerialization.fromJson(typeDefinition);
-            if (CollectionUtils.isNotEmpty(typesDef.enumTypesAsJavaList())) {
-                List<AtlasEnumDef> enumDefs = toAtlasEnumDefs(typesDef.enumTypesAsJavaList());
-                ret.setEnumDefs(enumDefs);
-            }
-
-            if (CollectionUtils.isNotEmpty(typesDef.structTypesAsJavaList())) {
-                List<AtlasStructDef> structDefs = toAtlasStructDefs(typesDef.structTypesAsJavaList());
-                ret.setStructDefs(structDefs);
-            }
-
-            if (CollectionUtils.isNotEmpty(typesDef.classTypesAsJavaList())) {
-                List<AtlasEntityDef> entityDefs = toAtlasEntityDefs(typesDef.classTypesAsJavaList(), registry);
-                ret.setEntityDefs(entityDefs);
-            }
-
-            if (CollectionUtils.isNotEmpty(typesDef.traitTypesAsJavaList())) {
-                List<AtlasClassificationDef> classificationDefs = toAtlasClassificationDefs(typesDef.traitTypesAsJavaList());
-                ret.setClassificationDefs(classificationDefs);
-            }
-
-        } catch (Exception e) {
-            LOG.error("Invalid type definition = {}", typeDefinition, e);
-            throw new AtlasBaseException(INVALID_TYPE_DEFINITION, typeDefinition);
-        }
-
-        return ret;
-    }
-
-    public static ImmutableList<String> getTypeNames(List<AtlasTypeDefHeader> atlasTypesDefs) {
-        List<String> ret = new ArrayList<String>();
-        if (CollectionUtils.isNotEmpty(atlasTypesDefs)) {
-            for (AtlasTypeDefHeader atlasTypesDef : atlasTypesDefs) {
-                ret.add(atlasTypesDef.getName());
-            }
-        }
-
-        return ImmutableList.copyOf(ret);
-    }
-
-    public static List<String> getTypeNames(AtlasTypesDef typesDef) {
-        List<AtlasTypeDefHeader> atlasTypesDefs = AtlasTypeUtil.toTypeDefHeader(typesDef);
-        return getTypeNames(atlasTypesDefs);
-    }
-
-    private static List<AtlasEnumDef> toAtlasEnumDefs(List<EnumTypeDefinition> enumTypeDefinitions) {
-        List<AtlasEnumDef> ret = new ArrayList<AtlasEnumDef>();
-
-        for (EnumTypeDefinition enumType : enumTypeDefinitions) {
-            AtlasEnumDef enumDef = new AtlasEnumDef();
-            enumDef.setName(enumType.name);
-            enumDef.setDescription(enumType.description);
-            enumDef.setTypeVersion(enumType.version);
-            enumDef.setElementDefs(getAtlasEnumElementDefs(enumType.enumValues));
-
-            ret.add(enumDef);
-        }
-
-        return ret;
-    }
-
-    private static List<AtlasStructDef> toAtlasStructDefs(List<StructTypeDefinition> structTypeDefinitions)
-            throws AtlasBaseException {
-        List<AtlasStructDef> ret = new ArrayList<AtlasStructDef>();
-
-        for (StructTypeDefinition structType : structTypeDefinitions) {
-            AtlasStructDef          structDef = new AtlasStructDef();
-            List<AtlasAttributeDef> attrDefs  = new ArrayList<AtlasAttributeDef>();
-
-            structDef.setName(structType.typeName);
-            structDef.setDescription(structType.typeDescription);
-            structDef.setTypeVersion(structType.typeVersion);
-
-            AttributeDefinition[] attrDefinitions = structType.attributeDefinitions;
-            for (AttributeDefinition attrDefinition : attrDefinitions) {
-                attrDefs.add(toAtlasAttributeDef(attrDefinition));
-            }
-
-            structDef.setAttributeDefs(attrDefs);
-            ret.add(structDef);
-        }
-
-        return ret;
-    }
-
-    private static List<AtlasClassificationDef> toAtlasClassificationDefs(List<HierarchicalTypeDefinition<TraitType>> traitTypeDefinitions)
-            throws AtlasBaseException {
-        List<AtlasClassificationDef> ret = new ArrayList<AtlasClassificationDef>();
-
-        for (HierarchicalTypeDefinition<TraitType> traitType : traitTypeDefinitions) {
-            AtlasClassificationDef  classifDef = new AtlasClassificationDef();
-            List<AtlasAttributeDef> attrDefs   = new ArrayList<AtlasAttributeDef>();
-
-            classifDef.setName(traitType.typeName);
-            classifDef.setDescription(traitType.typeDescription);
-            classifDef.setTypeVersion(traitType.typeVersion);
-            classifDef.setSuperTypes(traitType.superTypes);
-
-            AttributeDefinition[] attrDefinitions = traitType.attributeDefinitions;
-            for (AttributeDefinition attrDefinition : attrDefinitions) {
-                attrDefs.add(toAtlasAttributeDef(attrDefinition));
-            }
-
-            classifDef.setAttributeDefs(attrDefs);
-            ret.add(classifDef);
-        }
-
-        return ret;
-    }
-
-    private static List<AtlasEntityDef> toAtlasEntityDefs(List<HierarchicalTypeDefinition<ClassType>> classTypeDefinitions,
-                                                          AtlasTypeRegistry registry) throws AtlasBaseException {
-        List<AtlasEntityDef> atlasEntityDefs = new ArrayList<AtlasEntityDef>();
-
-        for (HierarchicalTypeDefinition<ClassType> classType : classTypeDefinitions) {
-            List<AtlasAttributeDef> attrDefs         = new ArrayList<AtlasAttributeDef>();
-            AtlasEntityDef          atlasEntityDef   = new AtlasEntityDef();
-            String                  classTypeDefName = classType.typeName;
-
-            atlasEntityDef.setName(classTypeDefName);
-            atlasEntityDef.setDescription(classType.typeDescription);
-            atlasEntityDef.setTypeVersion(classType.typeVersion);
-            atlasEntityDef.setSuperTypes(classType.superTypes);
-
-            AttributeDefinition[] attrDefinitions = classType.attributeDefinitions;
-            for (AttributeDefinition oldAttr : attrDefinitions) {
-                AtlasAttributeDef newAttr = toAtlasAttributeDef(oldAttr);
-                attrDefs.add(newAttr);
-            }
-
-            atlasEntityDef.setAttributeDefs(attrDefs);
-            atlasEntityDefs.add(atlasEntityDef);
-        }
-
-        return atlasEntityDefs;
-    }
-
-    private static String getArrayTypeName(String attrType) {
-        String ret = null;
-        if (isArrayType(attrType)) {
-            Set<String> typeNames = AtlasTypeUtil.getReferencedTypeNames(attrType);
-            if (typeNames.size() > 0) {
-                ret = typeNames.iterator().next();
-            }
-        }
-
-        return ret;
-    }
-
-    private static List<AtlasEnumElementDef> getAtlasEnumElementDefs(EnumValue[] enums) {
-        List<AtlasEnumElementDef> ret = new ArrayList<AtlasEnumElementDef>();
-
-        for (EnumValue enumElem : enums) {
-            ret.add(new AtlasEnumElementDef(enumElem.value, null, enumElem.ordinal));
-        }
-
-        return ret;
-    }
-
-    private static EnumValue[] getEnumValues(List<AtlasEnumElementDef> enumDefs) {
-        List<EnumValue> ret = new ArrayList<EnumValue>();
-
-        if (CollectionUtils.isNotEmpty(enumDefs)) {
-            for (AtlasEnumElementDef enumDef : enumDefs) {
-                if (enumDef != null) {
-                    ret.add(new EnumValue(enumDef.getValue(), enumDef.getOrdinal()));
-                }
-            }
-        }
-
-        return ret.toArray(new EnumValue[ret.size()]);
-    }
-
-    private static AtlasAttributeDef toAtlasAttributeDef(final AttributeDefinition attrDefinition) {
-        AtlasAttributeDef ret = new AtlasAttributeDef();
-
-        ret.setName(attrDefinition.name);
-        ret.setTypeName(attrDefinition.dataTypeName);
-        ret.setIsIndexable(attrDefinition.isIndexable);
-        ret.setIsUnique(attrDefinition.isUnique);
-        if (attrDefinition.isComposite) {
-            ret.addConstraint(new AtlasConstraintDef(CONSTRAINT_TYPE_OWNED_REF));
-        }
-
-        if (StringUtils.isNotBlank(attrDefinition.reverseAttributeName)) {
-            ret.addConstraint(new AtlasConstraintDef(CONSTRAINT_TYPE_INVERSE_REF,
-                                       new HashMap<String, Object>() {{
-                                           put(CONSTRAINT_PARAM_ATTRIBUTE, attrDefinition.reverseAttributeName);
-                                       }}));
-        }
-
-        // Multiplicity attribute mapping
-        Multiplicity multiplicity = attrDefinition.multiplicity;
-        int          minCount     = multiplicity.lower;
-        int          maxCount     = multiplicity.upper;
-        boolean      isUnique     = multiplicity.isUnique;
-
-        if (minCount == 0) {
-            ret.setIsOptional(true);
-            ret.setValuesMinCount(0);
-        } else {
-            ret.setIsOptional(false);
-            ret.setValuesMinCount(minCount);
-        }
-
-        if (maxCount < 2) {
-            ret.setCardinality(Cardinality.SINGLE);
-            ret.setValuesMaxCount(1);
-        } else {
-            if (!isUnique) {
-                ret.setCardinality(Cardinality.LIST);
-            } else {
-                ret.setCardinality(Cardinality.SET);
-            }
-
-            ret.setValuesMaxCount(maxCount);
-        }
-
-        return ret;
-    }
-
-    private static AttributeDefinition[] getAttributes(AtlasStructType structType, AtlasTypeRegistry registry) throws AtlasBaseException {
-        List<AttributeDefinition> ret      = new ArrayList<>();
-        List<AtlasAttributeDef>   attrDefs = structType.getStructDef().getAttributeDefs();
-
-        if (CollectionUtils.isNotEmpty(attrDefs)) {
-            for (AtlasAttributeDef attrDef : attrDefs) {
-                AtlasAttribute attribute = structType.getAttribute(attrDef.getName());
-
-                ret.add(AtlasStructDefStoreV1.toAttributeDefintion(attribute));
-            }
-        }
-
-        return ret.toArray(new AttributeDefinition[ret.size()]);
-    }
-}

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/d0f2ce5e/webapp/src/main/java/org/apache/atlas/web/resources/EntityService.java
----------------------------------------------------------------------
diff --git a/webapp/src/main/java/org/apache/atlas/web/resources/EntityService.java b/webapp/src/main/java/org/apache/atlas/web/resources/EntityService.java
index e3c9e1b..32c2cb8 100644
--- a/webapp/src/main/java/org/apache/atlas/web/resources/EntityService.java
+++ b/webapp/src/main/java/org/apache/atlas/web/resources/EntityService.java
@@ -27,7 +27,9 @@ import org.apache.atlas.catalog.EntityTagResourceProvider;
 import org.apache.atlas.catalog.InstanceRequest;
 import org.apache.atlas.catalog.Result;
 import org.apache.atlas.catalog.exception.CatalogException;
+import org.apache.atlas.exception.AtlasBaseException;
 import org.apache.atlas.services.MetadataService;
+import org.apache.atlas.store.AtlasTypeDefStore;
 import org.apache.atlas.utils.AtlasPerfTracer;
 import org.apache.atlas.web.util.Servlets;
 import org.slf4j.Logger;
@@ -63,8 +65,8 @@ public class EntityService extends BaseService {
     private final EntityTagResourceProvider entityTagResourceProvider;
 
     @Inject
-    public EntityService(MetadataService metadataService) throws AtlasException {
-        DefaultTypeSystem typeSystem = new DefaultTypeSystem(metadataService);
+    public EntityService(MetadataService metadataService, AtlasTypeDefStore typeDefStore) throws AtlasBaseException {
+        DefaultTypeSystem typeSystem = new DefaultTypeSystem(metadataService, typeDefStore);
         entityResourceProvider = new EntityResourceProvider(typeSystem);
         entityTagResourceProvider = new EntityTagResourceProvider(typeSystem);
     }

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/d0f2ce5e/webapp/src/main/java/org/apache/atlas/web/resources/TaxonomyService.java
----------------------------------------------------------------------
diff --git a/webapp/src/main/java/org/apache/atlas/web/resources/TaxonomyService.java b/webapp/src/main/java/org/apache/atlas/web/resources/TaxonomyService.java
index 13b0250..b13810f 100644
--- a/webapp/src/main/java/org/apache/atlas/web/resources/TaxonomyService.java
+++ b/webapp/src/main/java/org/apache/atlas/web/resources/TaxonomyService.java
@@ -22,7 +22,9 @@ import org.apache.atlas.AtlasException;
 import org.apache.atlas.catalog.*;
 import org.apache.atlas.catalog.exception.CatalogException;
 import org.apache.atlas.catalog.exception.InvalidPayloadException;
+import org.apache.atlas.exception.AtlasBaseException;
 import org.apache.atlas.services.MetadataService;
+import org.apache.atlas.store.AtlasTypeDefStore;
 import org.apache.atlas.utils.AtlasPerfTracer;
 import org.apache.atlas.web.util.Servlets;
 import org.slf4j.Logger;
@@ -58,8 +60,8 @@ public class TaxonomyService extends BaseService {
     private ResourceProvider termResourceProvider;
 
     @Inject
-    public void setMetadataService(MetadataService metadataService) throws AtlasException {
-        DefaultTypeSystem typeSystem = new DefaultTypeSystem(metadataService);
+    public void setMetadataService(MetadataService metadataService, AtlasTypeDefStore typeDefStore) throws AtlasBaseException {
+        DefaultTypeSystem typeSystem = new DefaultTypeSystem(metadataService, typeDefStore);
         taxonomyResourceProvider = createTaxonomyResourceProvider(typeSystem);
         termResourceProvider = createTermResourceProvider(typeSystem);
     }

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/d0f2ce5e/webapp/src/main/java/org/apache/atlas/web/resources/TypesResource.java
----------------------------------------------------------------------
diff --git a/webapp/src/main/java/org/apache/atlas/web/resources/TypesResource.java b/webapp/src/main/java/org/apache/atlas/web/resources/TypesResource.java
index 2c385c9..424ca58 100755
--- a/webapp/src/main/java/org/apache/atlas/web/resources/TypesResource.java
+++ b/webapp/src/main/java/org/apache/atlas/web/resources/TypesResource.java
@@ -26,7 +26,7 @@ import org.apache.atlas.model.typedef.AtlasTypesDef;
 import org.apache.atlas.type.AtlasTypeRegistry;
 import org.apache.atlas.typesystem.TypesDef;
 import org.apache.atlas.typesystem.json.TypesSerialization;
-import org.apache.atlas.util.RestUtils;
+import org.apache.atlas.repository.converters.TypeConverterUtil;
 import org.apache.atlas.utils.AtlasPerfTracer;
 import org.apache.atlas.web.rest.TypesREST;
 import org.apache.atlas.web.util.Servlets;
@@ -105,9 +105,9 @@ public class TypesResource {
                 LOG.debug("Creating type with definition {} ", typeDefinition);
             }
 
-            AtlasTypesDef createTypesDef  = RestUtils.toAtlasTypesDef(typeDefinition, typeRegistry);
+            AtlasTypesDef createTypesDef  = TypeConverterUtil.toAtlasTypesDef(typeDefinition, typeRegistry);
             AtlasTypesDef createdTypesDef = typesRest.createAtlasTypeDefs(createTypesDef);
-            List<String>  typeNames       = RestUtils.getTypeNames(createdTypesDef);
+            List<String>  typeNames       = TypeConverterUtil.getTypeNames(createdTypesDef);
 
             for (int i = 0; i < typeNames.size(); i++) {
                 final String name = typeNames.get(i);
@@ -173,9 +173,9 @@ public class TypesResource {
                 LOG.debug("Updating type with definition {} ", typeDefinition);
             }
 
-            AtlasTypesDef updateTypesDef  = RestUtils.toAtlasTypesDef(typeDefinition, typeRegistry);
+            AtlasTypesDef updateTypesDef  = TypeConverterUtil.toAtlasTypesDef(typeDefinition, typeRegistry);
             AtlasTypesDef updatedTypesDef = typesRest.updateAtlasTypeDefs(updateTypesDef);
-            List<String>  typeNames       = RestUtils.getTypeNames(updatedTypesDef);
+            List<String>  typeNames       = TypeConverterUtil.getTypeNames(updatedTypesDef);
 
             for (int i = 0; i < typeNames.size(); i++) {
                 final String name = typeNames.get(i);
@@ -231,7 +231,7 @@ public class TypesResource {
         JSONObject response = new JSONObject();
 
         try {
-            TypesDef typesDef       = RestUtils.toTypesDef(typeRegistry.getType(typeName), typeRegistry);;
+            TypesDef typesDef       = TypeConverterUtil.toTypesDef(typeRegistry.getType(typeName), typeRegistry);;
             String   typeDefinition = TypesSerialization.toJson(typesDef);
 
             response.put(AtlasClient.TYPENAME, typeName);
@@ -290,7 +290,7 @@ public class TypesResource {
         TypesREST typesRest  = resourceContext.getResource(TypesREST.class);
         JSONObject response  = new JSONObject();
         try {
-            List<String> result = RestUtils.getTypeNames(typesRest.getTypeDefHeaders(request));
+            List<String> result = TypeConverterUtil.getTypeNames(typesRest.getTypeDefHeaders(request));
 
             response.put(AtlasClient.RESULTS, new JSONArray(result));
             response.put(AtlasClient.COUNT, result.size());

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/d0f2ce5e/webapp/src/test/java/org/apache/atlas/util/RestUtilsTest.java
----------------------------------------------------------------------
diff --git a/webapp/src/test/java/org/apache/atlas/util/RestUtilsTest.java b/webapp/src/test/java/org/apache/atlas/util/RestUtilsTest.java
index 0cb112a..87259df 100644
--- a/webapp/src/test/java/org/apache/atlas/util/RestUtilsTest.java
+++ b/webapp/src/test/java/org/apache/atlas/util/RestUtilsTest.java
@@ -28,12 +28,12 @@ import java.util.List;
 import java.util.Map;
 
 import org.apache.atlas.exception.AtlasBaseException;
-import org.apache.atlas.model.instance.AtlasEntity;
 import org.apache.atlas.model.typedef.AtlasEntityDef;
 import org.apache.atlas.model.typedef.AtlasStructDef;
 import org.apache.atlas.model.typedef.AtlasStructDef.AtlasAttributeDef;
 import org.apache.atlas.model.typedef.AtlasTypesDef;
 import org.apache.atlas.repository.Constants;
+import org.apache.atlas.repository.converters.TypeConverterUtil;
 import org.apache.atlas.repository.graphdb.AtlasVertex;
 import org.apache.atlas.repository.store.graph.v1.AtlasGraphUtilsV1;
 import org.apache.atlas.repository.store.graph.v1.AtlasStructDefStoreV1;
@@ -178,7 +178,7 @@ public class RestUtilsTest {
         for (int i = 0; i < toConvert.size(); i++) {
             AtlasEntityDef entityDef = toConvert.get(i);
             AtlasEntityType entity = reg.getEntityTypeByName(entityDef.getName());
-            HierarchicalTypeDefinition<ClassType> converted = RestUtils.toTypesDef(entity, reg)
+            HierarchicalTypeDefinition<ClassType> converted = TypeConverterUtil.toTypesDef(entity, reg)
                     .classTypesAsJavaList().get(0);
             result.add(converted);
         }
@@ -205,7 +205,7 @@ public class RestUtilsTest {
 
         String json = TypesSerialization.toJson(toConvert);
         AtlasTypeRegistry emptyRegistry = new AtlasTypeRegistry();
-        AtlasTypesDef converted = RestUtils.toAtlasTypesDef(json, emptyRegistry);
+        AtlasTypesDef converted = TypeConverterUtil.toAtlasTypesDef(json, emptyRegistry);
         List<AtlasEntityDef> convertedEntityDefs = converted.getEntityDefs();
         return convertedEntityDefs;
     }

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/d0f2ce5e/webapp/src/test/java/org/apache/atlas/web/resources/TaxonomyServiceTest.java
----------------------------------------------------------------------
diff --git a/webapp/src/test/java/org/apache/atlas/web/resources/TaxonomyServiceTest.java b/webapp/src/test/java/org/apache/atlas/web/resources/TaxonomyServiceTest.java
index cba78f3..54a9b9a 100644
--- a/webapp/src/test/java/org/apache/atlas/web/resources/TaxonomyServiceTest.java
+++ b/webapp/src/test/java/org/apache/atlas/web/resources/TaxonomyServiceTest.java
@@ -48,7 +48,9 @@ import org.apache.atlas.catalog.ResourceProvider;
 import org.apache.atlas.catalog.Result;
 import org.apache.atlas.catalog.TaxonomyResourceProvider;
 import org.apache.atlas.catalog.TermPath;
+import org.apache.atlas.exception.AtlasBaseException;
 import org.apache.atlas.services.MetadataService;
+import org.apache.atlas.store.AtlasTypeDefStore;
 import org.easymock.Capture;
 import org.testng.annotations.Test;
 
@@ -60,6 +62,7 @@ public class TaxonomyServiceTest {
     public void testGetTaxonomy() throws Exception {
         String taxonomyName = "testTaxonomy";
         MetadataService metadataService = createStrictMock(MetadataService.class);
+        AtlasTypeDefStore typeDefStore = createStrictMock(AtlasTypeDefStore.class);
         ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
         ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
         UriInfo uriInfo = createNiceMock(UriInfo.class);
@@ -78,7 +81,7 @@ public class TaxonomyServiceTest {
         replay(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
 
         TestTaxonomyService service = new TestTaxonomyService(
-                metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
+                metadataService, typeDefStore, taxonomyResourceProvider, termResourceProvider, serializer);
         Response response = service.getTaxonomy(null, uriInfo, taxonomyName);
 
         Request request = requestCapture.getValue();
@@ -89,12 +92,13 @@ public class TaxonomyServiceTest {
         assertEquals(response.getStatus(), 200);
         assertEquals(response.getEntity(), "Taxonomy Get Response");
 
-        verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
+        verify(uriInfo, taxonomyResourceProvider, termResourceProvider, serializer);
     }
 
     @Test
     public void testGetTaxonomies() throws Exception {
         MetadataService metadataService = createStrictMock(MetadataService.class);
+        AtlasTypeDefStore typeDefStore = createStrictMock(AtlasTypeDefStore.class);
         ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
         ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
         UriInfo uriInfo = createNiceMock(UriInfo.class);
@@ -117,7 +121,7 @@ public class TaxonomyServiceTest {
 
         // instantiate service and invoke method being tested
         TestTaxonomyService service = new TestTaxonomyService(
-                metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
+                metadataService, typeDefStore, taxonomyResourceProvider, termResourceProvider, serializer);
         Response response = service.getTaxonomies(null, uriInfo);
 
         Request request = requestCapture.getValue();
@@ -127,12 +131,13 @@ public class TaxonomyServiceTest {
         assertEquals(response.getStatus(), 200);
         assertEquals(response.getEntity(), "Taxonomy Get Response");
 
-        verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
+        verify(uriInfo, taxonomyResourceProvider, termResourceProvider, serializer);
     }
 
     @Test
     public void testCreateTaxonomy() throws Exception {
         MetadataService metadataService = createStrictMock(MetadataService.class);
+        AtlasTypeDefStore typeDefStore = createStrictMock(AtlasTypeDefStore.class);
         ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
         ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
         UriInfo uriInfo = createNiceMock(UriInfo.class);
@@ -148,7 +153,7 @@ public class TaxonomyServiceTest {
 
         // instantiate service and invoke method being tested
         TestTaxonomyService service = new TestTaxonomyService(
-                metadataService, taxonomyResourceProvider, termResourceProvider, null);
+            metadataService, typeDefStore, taxonomyResourceProvider, termResourceProvider, null);
         Response response = service.createTaxonomy(body, null, uriInfo, "testTaxonomy");
 
         Request request = requestCapture.getValue();
@@ -162,12 +167,13 @@ public class TaxonomyServiceTest {
         assertEquals(createResults.href, "http://localhost:21000/api/atlas/v1/taxonomies/testTaxonomy");
         assertEquals(createResults.status, 201);
 
-        verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider);
+        verify(uriInfo, taxonomyResourceProvider, termResourceProvider);
     }
 
     @Test
     public void testDeleteTaxonomy() throws Exception {
         MetadataService metadataService = createStrictMock(MetadataService.class);
+        AtlasTypeDefStore typeDefStore = createStrictMock(AtlasTypeDefStore.class);
         ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
         ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
         UriInfo uriInfo = createNiceMock(UriInfo.class);
@@ -182,7 +188,7 @@ public class TaxonomyServiceTest {
 
         // instantiate service and invoke method being tested
         TestTaxonomyService service = new TestTaxonomyService(
-                metadataService, taxonomyResourceProvider, termResourceProvider, null);
+            metadataService, typeDefStore, taxonomyResourceProvider, termResourceProvider, null);
         Response response = service.deleteTaxonomy(null, uriInfo, "testTaxonomy");
 
         Request request = requestCapture.getValue();
@@ -195,7 +201,7 @@ public class TaxonomyServiceTest {
         assertEquals(createResults.href, "http://localhost:21000/api/atlas/v1/taxonomies/testTaxonomy");
         assertEquals(createResults.status, 200);
 
-        verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider);
+        verify(uriInfo, taxonomyResourceProvider, termResourceProvider);
     }
 
     @Test
@@ -203,6 +209,7 @@ public class TaxonomyServiceTest {
         String taxonomyName = "testTaxonomy";
         String termName = "testTaxonomy.termName";
         MetadataService metadataService = createStrictMock(MetadataService.class);
+        AtlasTypeDefStore typeDefStore = createStrictMock(AtlasTypeDefStore.class);
         ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
         ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
         UriInfo uriInfo = createNiceMock(UriInfo.class);
@@ -221,7 +228,7 @@ public class TaxonomyServiceTest {
         replay(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
 
         TestTaxonomyService service = new TestTaxonomyService(
-                metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
+            metadataService, typeDefStore, taxonomyResourceProvider, termResourceProvider, serializer);
         Response response = service.getTaxonomyTerm(null, uriInfo, taxonomyName, termName);
 
         Request request = requestCapture.getValue();
@@ -233,12 +240,13 @@ public class TaxonomyServiceTest {
         assertEquals(response.getStatus(), 200);
         assertEquals(response.getEntity(), "Taxonomy Term Get Response");
 
-        verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
+        verify(uriInfo, taxonomyResourceProvider, termResourceProvider, serializer);
     }
 
     @Test
     public void testGetTaxonomyTerms() throws Exception {
         MetadataService metadataService = createStrictMock(MetadataService.class);
+        AtlasTypeDefStore typeDefStore = createStrictMock(AtlasTypeDefStore.class);
         ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
         ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
         UriInfo uriInfo = createNiceMock(UriInfo.class);
@@ -261,7 +269,7 @@ public class TaxonomyServiceTest {
 
         // instantiate service and invoke method being tested
         TestTaxonomyService service = new TestTaxonomyService(
-                metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
+            metadataService, typeDefStore, taxonomyResourceProvider, termResourceProvider, serializer);
         Response response = service.getTaxonomyTerms(null, uriInfo, "testTaxonomy");
 
         Request request = requestCapture.getValue();
@@ -273,12 +281,13 @@ public class TaxonomyServiceTest {
         assertEquals(response.getStatus(), 200);
         assertEquals(response.getEntity(), "Taxonomy Term Get Response");
 
-        verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
+        verify(uriInfo, taxonomyResourceProvider, termResourceProvider, serializer);
     }
 
     @Test
     public void testGetSubTerms_instance() throws Exception {
         MetadataService metadataService = createStrictMock(MetadataService.class);
+        AtlasTypeDefStore typeDefStore = createStrictMock(AtlasTypeDefStore.class);
         ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
         ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
         UriInfo uriInfo = createNiceMock(UriInfo.class);
@@ -308,7 +317,7 @@ public class TaxonomyServiceTest {
 
         // instantiate service and invoke method being tested
         TestTaxonomyService service = new TestTaxonomyService(
-                metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
+            metadataService, typeDefStore, taxonomyResourceProvider, termResourceProvider, serializer);
         Response response = service.getSubTerms(null, uriInfo, "testTaxonomy", "testTerm", "/terms/testTerm2");
 
         Request request = requestCapture.getValue();
@@ -320,13 +329,14 @@ public class TaxonomyServiceTest {
         assertEquals(response.getStatus(), 200);
         assertEquals(response.getEntity(), "Taxonomy Term Get Response");
 
-        verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider, serializer,
+        verify(uriInfo, taxonomyResourceProvider, termResourceProvider, serializer,
                 segment1, segment2, segment3);
     }
 
     @Test
     public void testGetSubTerms_collection() throws Exception {
         MetadataService metadataService = createStrictMock(MetadataService.class);
+        AtlasTypeDefStore typeDefStore = createStrictMock(AtlasTypeDefStore.class);
         ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
         ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
         UriInfo uriInfo = createNiceMock(UriInfo.class);
@@ -358,7 +368,7 @@ public class TaxonomyServiceTest {
 
         // instantiate service and invoke method being tested
         TestTaxonomyService service = new TestTaxonomyService(
-                metadataService, taxonomyResourceProvider, termResourceProvider, serializer);
+            metadataService, typeDefStore, taxonomyResourceProvider, termResourceProvider, serializer);
         Response response = service.getSubTerms(null, uriInfo, "testTaxonomy", "testTerm", "/terms/testTerm2/terms");
 
         Request request = requestCapture.getValue();
@@ -370,7 +380,7 @@ public class TaxonomyServiceTest {
         assertEquals(response.getStatus(), 200);
         assertEquals(response.getEntity(), "Taxonomy Term Get Response");
 
-        verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider, serializer,
+        verify(uriInfo, taxonomyResourceProvider, termResourceProvider, serializer,
                 segment1, segment2, segment3);
     }
 
@@ -379,6 +389,7 @@ public class TaxonomyServiceTest {
         String taxonomyName = "testTaxonomy";
         String termName = "testTerm";
         MetadataService metadataService = createStrictMock(MetadataService.class);
+        AtlasTypeDefStore typeDefStore = createStrictMock(AtlasTypeDefStore.class);
         ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
         ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
         UriInfo uriInfo = createNiceMock(UriInfo.class);
@@ -394,7 +405,7 @@ public class TaxonomyServiceTest {
 
         // instantiate service and invoke method being tested
         TestTaxonomyService service = new TestTaxonomyService(
-                metadataService, taxonomyResourceProvider, termResourceProvider, null);
+            metadataService, typeDefStore, taxonomyResourceProvider, termResourceProvider, null);
         Response response = service.createTerm(body, null, uriInfo, taxonomyName, termName);
 
         Request request = requestCapture.getValue();
@@ -409,7 +420,7 @@ public class TaxonomyServiceTest {
         assertEquals(createResults.href, "http://localhost:21000/api/atlas/v1/taxonomies/testTaxonomy/terms/testTerm");
         assertEquals(createResults.status, 201);
 
-        verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider);
+        verify(uriInfo, taxonomyResourceProvider, termResourceProvider);
     }
 
     @Test
@@ -417,6 +428,7 @@ public class TaxonomyServiceTest {
         String taxonomyName = "testTaxonomy";
         String termName = "testTerm";
         MetadataService metadataService = createStrictMock(MetadataService.class);
+        AtlasTypeDefStore typeDefStore = createStrictMock(AtlasTypeDefStore.class);
         ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
         ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
         UriInfo uriInfo = createNiceMock(UriInfo.class);
@@ -432,7 +444,7 @@ public class TaxonomyServiceTest {
 
         // instantiate service and invoke method being tested
         TestTaxonomyService service = new TestTaxonomyService(
-                metadataService, taxonomyResourceProvider, termResourceProvider, null);
+            metadataService, typeDefStore, taxonomyResourceProvider, termResourceProvider, null);
         Response response = service.createSubTerm(body, null, uriInfo, taxonomyName, termName, "/terms/testTerm2");
 
         Request request = requestCapture.getValue();
@@ -447,12 +459,13 @@ public class TaxonomyServiceTest {
         assertEquals(createResults.href, "http://localhost:21000/api/atlas/v1/taxonomies/testTaxonomy/terms/testTerm/terms/testTerm2");
         assertEquals(createResults.status, 201);
 
-        verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider);
+        verify(uriInfo, taxonomyResourceProvider, termResourceProvider);
     }
 
     @Test
     public void testDeleteTerm() throws Exception {
         MetadataService metadataService = createStrictMock(MetadataService.class);
+        AtlasTypeDefStore typeDefStore = createStrictMock(AtlasTypeDefStore.class);
         ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
         ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
         UriInfo uriInfo = createNiceMock(UriInfo.class);
@@ -467,7 +480,7 @@ public class TaxonomyServiceTest {
 
         // instantiate service and invoke method being tested
         TestTaxonomyService service = new TestTaxonomyService(
-                metadataService, taxonomyResourceProvider, termResourceProvider, null);
+            metadataService, typeDefStore, taxonomyResourceProvider, termResourceProvider, null);
         Response response = service.deleteTerm(null, uriInfo, "testTaxonomy", "testTerm");
 
         Request request = requestCapture.getValue();
@@ -481,12 +494,13 @@ public class TaxonomyServiceTest {
         assertEquals(createResults.href, "http://localhost:21000/api/atlas/v1/taxonomies/testTaxonomy/terms/testTerm");
         assertEquals(createResults.status, 200);
 
-        verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider);
+        verify(uriInfo, taxonomyResourceProvider, termResourceProvider);
     }
 
     @Test
     public void testDeleteSubTerm() throws Exception {
         MetadataService metadataService = createStrictMock(MetadataService.class);
+        AtlasTypeDefStore typeDefStore = createStrictMock(AtlasTypeDefStore.class);
         ResourceProvider taxonomyResourceProvider = createStrictMock(ResourceProvider.class);
         ResourceProvider termResourceProvider = createStrictMock(ResourceProvider.class);
         UriInfo uriInfo = createNiceMock(UriInfo.class);
@@ -501,7 +515,7 @@ public class TaxonomyServiceTest {
 
         // instantiate service and invoke method being tested
         TestTaxonomyService service = new TestTaxonomyService(
-                metadataService, taxonomyResourceProvider, termResourceProvider, null);
+            metadataService, typeDefStore, taxonomyResourceProvider, termResourceProvider, null);
         Response response = service.deleteSubTerm(null, uriInfo, "testTaxonomy", "testTerm", "terms/testTerm2");
 
         Request request = requestCapture.getValue();
@@ -515,7 +529,7 @@ public class TaxonomyServiceTest {
         assertEquals(createResults.href, "http://localhost:21000/api/atlas/v1/taxonomies/testTaxonomy/terms/testTerm/terms/testTerm2");
         assertEquals(createResults.status, 200);
 
-        verify(uriInfo, metadataService, taxonomyResourceProvider, termResourceProvider);
+        verify(uriInfo, taxonomyResourceProvider, termResourceProvider);
     }
 
     private static class TestTaxonomyService extends TaxonomyService {
@@ -525,14 +539,15 @@ public class TaxonomyServiceTest {
         private boolean transactionInitialized = false;
 
         public TestTaxonomyService(MetadataService metadataService,
+                                   AtlasTypeDefStore typeDefStore,
                                    ResourceProvider taxonomyProvider,
                                    ResourceProvider termResourceProvider,
-                                   JsonSerializer serializer) throws AtlasException {
+                                   JsonSerializer serializer) throws AtlasBaseException {
 
             testTaxonomyResourceProvider = taxonomyProvider;
             testTermResourceProvider = termResourceProvider;
             testSerializer = serializer;
-            setMetadataService(metadataService);
+            setMetadataService(metadataService, typeDefStore);
         }
 
         @Override


Mime
View raw message