atlas-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From shweth...@apache.org
Subject incubator-atlas git commit: ATLAS-1174 Framework to apply updates to types in the type-system (sarath.kum4r@gmail.com via shwethags)
Date Wed, 28 Sep 2016 11:21:57 GMT
Repository: incubator-atlas
Updated Branches:
  refs/heads/master 71e0e09b9 -> 180c6e571


ATLAS-1174 Framework to apply updates to types in the type-system (sarath.kum4r@gmail.com via shwethags)


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

Branch: refs/heads/master
Commit: 180c6e571efed300e067bfa0cd009f7ce55d2ee5
Parents: 71e0e09
Author: Shwetha GS <sshivalingamurthy@hortonworks.com>
Authored: Wed Sep 28 12:37:17 2016 +0530
Committer: Shwetha GS <sshivalingamurthy@hortonworks.com>
Committed: Wed Sep 28 12:37:17 2016 +0530

----------------------------------------------------------------------
 .../java/org/apache/atlas/AtlasConstants.java   |   1 +
 .../org/apache/atlas/repository/Constants.java  |   1 +
 release-log.txt                                 |   1 +
 .../typestore/GraphBackedTypeStore.java         |  37 ++-
 .../atlas/services/AtlasPatchHandler.java       | 173 +++++++++++
 .../atlas/services/AtlasTypeAttributePatch.java | 296 +++++++++++++++++++
 .../apache/atlas/services/AtlasTypePatch.java   | 104 +++++++
 .../atlas/services/DefaultMetadataService.java  |   2 +
 .../service/DefaultMetadataServiceTest.java     |  44 ++-
 .../typesystem/types/AbstractDataType.java      |  18 +-
 .../atlas/typesystem/types/ClassType.java       |  14 +-
 .../apache/atlas/typesystem/types/EnumType.java |   9 +-
 .../typesystem/types/EnumTypeDefinition.java    |   9 +-
 .../typesystem/types/HierarchicalType.java      |  15 +-
 .../types/HierarchicalTypeDefinition.java       |  43 +--
 .../atlas/typesystem/types/IDataType.java       |   2 +
 .../atlas/typesystem/types/StructType.java      |  14 +-
 .../typesystem/types/StructTypeDefinition.java  |  19 +-
 .../atlas/typesystem/types/TraitType.java       |  14 +-
 .../atlas/typesystem/types/TypeSystem.java      |  16 +-
 .../atlas/typesystem/types/utils/TypesUtil.java |  11 +
 .../typesystem/json/TypesSerialization.scala    |  35 ++-
 22 files changed, 813 insertions(+), 65 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/common/src/main/java/org/apache/atlas/AtlasConstants.java
----------------------------------------------------------------------
diff --git a/common/src/main/java/org/apache/atlas/AtlasConstants.java b/common/src/main/java/org/apache/atlas/AtlasConstants.java
index 17ffbd7..8521f63 100644
--- a/common/src/main/java/org/apache/atlas/AtlasConstants.java
+++ b/common/src/main/java/org/apache/atlas/AtlasConstants.java
@@ -33,5 +33,6 @@ public final class AtlasConstants {
     public static final String ATLAS_REST_ADDRESS_KEY = "atlas.rest.address";
     public static final String DEFAULT_ATLAS_REST_ADDRESS = "http://localhost:21000";
     public static final int ATLAS_SHUTDOWN_HOOK_PRIORITY = 30;
+    public static final String DEFAULT_TYPE_VERSION = "1.0";
 
 }

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/common/src/main/java/org/apache/atlas/repository/Constants.java
----------------------------------------------------------------------
diff --git a/common/src/main/java/org/apache/atlas/repository/Constants.java b/common/src/main/java/org/apache/atlas/repository/Constants.java
index d7f9c89..66f5bb0 100644
--- a/common/src/main/java/org/apache/atlas/repository/Constants.java
+++ b/common/src/main/java/org/apache/atlas/repository/Constants.java
@@ -54,6 +54,7 @@ public final class Constants {
     public static final String VERTEX_TYPE_PROPERTY_KEY = INTERNAL_PROPERTY_KEY_PREFIX + "type";
     public static final String TYPENAME_PROPERTY_KEY = INTERNAL_PROPERTY_KEY_PREFIX + "type.name";
     public static final String TYPEDESCRIPTION_PROPERTY_KEY = INTERNAL_PROPERTY_KEY_PREFIX + "type.description";
+    public static final String TYPEVERSION_PROPERTY_KEY = INTERNAL_PROPERTY_KEY_PREFIX + "type.version";
 
     /**
      * Trait names property key and index name.

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/release-log.txt
----------------------------------------------------------------------
diff --git a/release-log.txt b/release-log.txt
index 88be4b6..0d8f5bf 100644
--- a/release-log.txt
+++ b/release-log.txt
@@ -9,6 +9,7 @@ ATLAS-1060 Add composite indexes for exact match performance improvements for al
 ATLAS-1127 Modify creation and modification timestamps to Date instead of Long(sumasai)
 
 ALL CHANGES:
+ATLAS-1174 Framework to apply updates to types in the type-system (sarath.kum4r@gmail.com via shwethags)
 ATLAS-1155 Errors in Eclipse when I bring in the latest code (davidrad via shwethags)
 ATLAS-1098 Atlas allows creation of tag with name "isa" which causes exceptions during search (apoorvnaik via shwethags)
 ATLAS-1142 Lineage UI Improvement (kevalbhatt via shwethags)

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/repository/src/main/java/org/apache/atlas/repository/typestore/GraphBackedTypeStore.java
----------------------------------------------------------------------
diff --git a/repository/src/main/java/org/apache/atlas/repository/typestore/GraphBackedTypeStore.java b/repository/src/main/java/org/apache/atlas/repository/typestore/GraphBackedTypeStore.java
index a94d157..b7e706f 100755
--- a/repository/src/main/java/org/apache/atlas/repository/typestore/GraphBackedTypeStore.java
+++ b/repository/src/main/java/org/apache/atlas/repository/typestore/GraphBackedTypeStore.java
@@ -26,6 +26,7 @@ import com.thinkaurelius.titan.core.TitanGraph;
 import com.tinkerpop.blueprints.Direction;
 import com.tinkerpop.blueprints.Edge;
 import com.tinkerpop.blueprints.Vertex;
+import org.apache.atlas.AtlasConstants;
 import org.apache.atlas.AtlasException;
 import org.apache.atlas.GraphTransaction;
 import org.apache.atlas.repository.Constants;
@@ -90,14 +91,14 @@ public class GraphBackedTypeStore implements ITypeStore {
 
             case STRUCT:
                 StructType structType = (StructType) dataType;
-                storeInGraph(typeSystem, dataType.getTypeCategory(), dataType.getName(), dataType.getDescription(),
+                storeInGraph(typeSystem, dataType.getTypeCategory(), dataType.getName(), dataType.getDescription(), dataType.getVersion(),
                         ImmutableList.copyOf(structType.infoToNameMap.keySet()), ImmutableSet.<String>of());
                 break;
 
             case TRAIT:
             case CLASS:
                 HierarchicalType type = (HierarchicalType) dataType;
-                storeInGraph(typeSystem, dataType.getTypeCategory(), dataType.getName(), type.getDescription(), type.immediateAttrs,
+                storeInGraph(typeSystem, dataType.getTypeCategory(), dataType.getName(), type.getDescription(), type.getVersion(), type.immediateAttrs,
                         type.superTypes);
                 break;
 
@@ -108,7 +109,7 @@ public class GraphBackedTypeStore implements ITypeStore {
     }
 
     private void storeInGraph(EnumType dataType) {
-        Vertex vertex = createVertex(dataType.getTypeCategory(), dataType.getName(), dataType.getDescription());
+        Vertex vertex = createVertex(dataType.getTypeCategory(), dataType.getName(), dataType.getDescription(), dataType.getVersion());
         List<String> values = new ArrayList<>(dataType.values().size());
         for (EnumValue enumValue : dataType.values()) {
             String key = getPropertyKey(dataType.getName(), enumValue.value);
@@ -130,9 +131,9 @@ public class GraphBackedTypeStore implements ITypeStore {
         return PROPERTY_PREFIX + "edge." + parent + "." + child;
     }
 
-    private void storeInGraph(TypeSystem typeSystem, DataTypes.TypeCategory category, String typeName, String typeDescription,
+    private void storeInGraph(TypeSystem typeSystem, DataTypes.TypeCategory category, String typeName, String typeDescription, String typeVersion,
             ImmutableList<AttributeInfo> attributes, ImmutableSet<String> superTypes) throws AtlasException {
-        Vertex vertex = createVertex(category, typeName, typeDescription);
+        Vertex vertex = createVertex(category, typeName, typeDescription, typeVersion);
         List<String> attrNames = new ArrayList<>();
         if (attributes != null) {
             for (AttributeInfo attribute : attributes) {
@@ -152,7 +153,7 @@ public class GraphBackedTypeStore implements ITypeStore {
         if (superTypes != null) {
             for (String superTypeName : superTypes) {
                 HierarchicalType superType = typeSystem.getDataType(HierarchicalType.class, superTypeName);
-                Vertex superVertex = createVertex(superType.getTypeCategory(), superTypeName, superType.getDescription());
+                Vertex superVertex = createVertex(superType.getTypeCategory(), superTypeName, superType.getDescription(), AtlasConstants.DEFAULT_TYPE_VERSION);
                 graphHelper.getOrCreateEdge(vertex, superVertex, SUPERTYPE_EDGE_LABEL);
             }
         }
@@ -200,7 +201,7 @@ public class GraphBackedTypeStore implements ITypeStore {
 
         for (IDataType attrType : attrDataTypes) {
             if (!coreTypes.contains(attrType.getName())) {
-                Vertex attrVertex = createVertex(attrType.getTypeCategory(), attrType.getName(), attrType.getDescription());
+                Vertex attrVertex = createVertex(attrType.getTypeCategory(), attrType.getName(), attrType.getDescription(), attrType.getVersion());
                 String label = getEdgeLabel(vertexTypeName, attribute.name);
                 graphHelper.getOrCreateEdge(vertex, attrVertex, label);
             }
@@ -238,6 +239,7 @@ public class GraphBackedTypeStore implements ITypeStore {
             DataTypes.TypeCategory typeCategory = vertex.getProperty(Constants.TYPE_CATEGORY_PROPERTY_KEY);
             String typeName = vertex.getProperty(Constants.TYPENAME_PROPERTY_KEY);
             String typeDescription = vertex.getProperty(Constants.TYPEDESCRIPTION_PROPERTY_KEY);
+            String typeVersion = vertex.getProperty(Constants.TYPEVERSION_PROPERTY_KEY);
             LOG.info("Restoring type {}.{}.{}", typeCategory, typeName, typeDescription);
             switch (typeCategory) {
             case ENUM:
@@ -246,19 +248,19 @@ public class GraphBackedTypeStore implements ITypeStore {
 
             case STRUCT:
                 AttributeDefinition[] attributes = getAttributes(vertex, typeName);
-                structs.add(new StructTypeDefinition(typeName, typeDescription, attributes));
+                structs.add(new StructTypeDefinition(typeName, typeDescription, typeVersion, attributes));
                 break;
 
             case CLASS:
                 ImmutableSet<String> superTypes = getSuperTypes(vertex);
                 attributes = getAttributes(vertex, typeName);
-                classTypes.add(new HierarchicalTypeDefinition(ClassType.class, typeName, typeDescription, superTypes, attributes));
+                classTypes.add(new HierarchicalTypeDefinition(ClassType.class, typeName, typeDescription, typeVersion, superTypes, attributes));
                 break;
 
             case TRAIT:
                 superTypes = getSuperTypes(vertex);
                 attributes = getAttributes(vertex, typeName);
-                traits.add(new HierarchicalTypeDefinition(TraitType.class, typeName, typeDescription, superTypes, attributes));
+                traits.add(new HierarchicalTypeDefinition(TraitType.class, typeName, typeDescription, typeVersion, superTypes, attributes));
                 break;
 
             default:
@@ -271,13 +273,14 @@ public class GraphBackedTypeStore implements ITypeStore {
     private EnumTypeDefinition getEnumType(Vertex vertex) {
         String typeName = vertex.getProperty(Constants.TYPENAME_PROPERTY_KEY);
         String typeDescription = vertex.getProperty(Constants.TYPEDESCRIPTION_PROPERTY_KEY);
+        String typeVersion = vertex.getProperty(Constants.TYPEVERSION_PROPERTY_KEY);
         List<EnumValue> enumValues = new ArrayList<>();
         List<String> values = graphHelper.getProperty(vertex, getPropertyKey(typeName));
         for (String value : values) {
             String valueProperty = getPropertyKey(typeName, value);
             enumValues.add(new EnumValue(value, (Integer) graphHelper.getProperty(vertex, valueProperty)));
         }
-        return new EnumTypeDefinition(typeName, typeDescription, enumValues.toArray(new EnumValue[enumValues.size()]));
+        return new EnumTypeDefinition(typeName, typeDescription, typeVersion, enumValues.toArray(new EnumValue[enumValues.size()]));
     }
 
     private ImmutableSet<String> getSuperTypes(Vertex vertex) {
@@ -324,7 +327,7 @@ public class GraphBackedTypeStore implements ITypeStore {
         return vertex;
     }
 
-    private Vertex createVertex(DataTypes.TypeCategory category, String typeName, String typeDescription) {
+    private Vertex createVertex(DataTypes.TypeCategory category, String typeName, String typeDescription, String typeVersion) {
         Vertex vertex = findVertex(category, typeName);
         if (vertex == null) {
             LOG.debug("Adding vertex {}{}", PROPERTY_PREFIX, typeName);
@@ -341,6 +344,16 @@ public class GraphBackedTypeStore implements ITypeStore {
         } else {
             LOG.debug(" type description is null ");
         }
+
+        if (typeVersion != null) {
+            String oldVersion = getPropertyKey(Constants.TYPEVERSION_PROPERTY_KEY);
+            if (!typeVersion.equals(oldVersion)) {
+                setProperty(vertex, Constants.TYPEVERSION_PROPERTY_KEY, typeVersion);
+                LOG.info(" updating type {} to version {}", typeName, typeVersion);
+            }
+        } else {
+            LOG.info(" type version is null ");
+        }
         return vertex;
     }
 }

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/repository/src/main/java/org/apache/atlas/services/AtlasPatchHandler.java
----------------------------------------------------------------------
diff --git a/repository/src/main/java/org/apache/atlas/services/AtlasPatchHandler.java b/repository/src/main/java/org/apache/atlas/services/AtlasPatchHandler.java
new file mode 100644
index 0000000..f916169
--- /dev/null
+++ b/repository/src/main/java/org/apache/atlas/services/AtlasPatchHandler.java
@@ -0,0 +1,173 @@
+/**
+ * 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
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.atlas.services;
+
+
+import com.google.gson.FieldNamingPolicy;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonParseException;
+import com.google.gson.JsonSyntaxException;
+import org.apache.atlas.services.AtlasTypePatch.PatchContent;
+import org.apache.atlas.services.AtlasTypePatch.PatchData;
+import org.apache.atlas.services.AtlasTypePatch.PatchResult;
+import org.apache.atlas.services.AtlasTypePatch.PatchStatus;
+import org.apache.atlas.typesystem.types.Multiplicity;
+import org.apache.atlas.typesystem.types.TypeSystem;
+import org.apache.atlas.typesystem.types.TypeUpdateException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class AtlasPatchHandler {
+
+    private static final Logger LOG = LoggerFactory.getLogger(AtlasPatchHandler.class);
+
+    public static void handlePatches(DefaultMetadataService metadataService, TypeSystem typeSystem) throws TypeUpdateException {
+
+        Map<String, AtlasTypePatch> patchHandlerMap = initializePatchHandlerMap(metadataService, typeSystem);
+
+        if (patchHandlerMap == null || patchHandlerMap.isEmpty())
+            return;
+
+        String patchDirName = ReservedTypesRegistrar.getTypesDir() + File.separator + "patches";
+        LOG.info("Checking for any patches to be applied to the type system in " + patchDirName);
+
+        File patchDir = new File(patchDirName);
+        if (!patchDir.exists()) {
+            LOG.info("Patch directory {} doesn't exist, not applying any patches", patchDirName);
+            return;
+        }
+
+        File[] patchFiles = patchDir.listFiles();
+        if (patchFiles == null  || patchFiles.length == 0) {
+            LOG.info("No patch files found in {}, not applying any patches", patchDirName);
+            return;
+        }
+
+        // Sort the patch files based on file name.
+        Arrays.sort(patchFiles, new Comparator<File>() {
+            public int compare(File f1, File f2) {
+                return String.valueOf(f1.getName()).compareTo(f2.getName());
+            }
+        });
+
+        LOG.info("Found " + patchFiles.length + " patch files to process.");
+        int patchNumber = 0;
+        Gson gson = initializeGson();
+        AtlasTypePatch typePatch;
+
+        for (File patchFile : patchFiles) {
+            try {
+                LOG.info("Processing patch file " + (++patchNumber) + " - " + patchFile.getAbsolutePath());
+                String content = new String(Files.readAllBytes(patchFile.toPath()), StandardCharsets.UTF_8);
+                PatchContent patchContent = gson.fromJson(content, PatchContent.class);
+                PatchData[] patchDatas = patchContent.getPatches();
+                PatchResult result;
+                int patchCounter = 0;
+
+                for (PatchData patch : patchDatas) {
+                    typePatch = patchHandlerMap.get(patch.getAction());
+                    if (typePatch != null) {
+                        result = typePatch.applyPatch(patch);
+
+                        if (result != null) {
+                            LOG.info(result.getMessage() + " Patch " + (++patchCounter) + " out of " + patchDatas.length + " processed in : " + patchFile.toPath());
+                            if (result.getStatus().equals(PatchStatus.FAILED)) {
+                                throw new TypeUpdateException(result.getMessage() + " patch " + patchNumber + " failed in :" + patchFile.getAbsolutePath());
+                            }
+                        }
+                    }
+                }
+
+            } catch (IOException e) {
+                throw new TypeUpdateException("Unable to read patch file from " + patchFile.getAbsolutePath());
+            } catch (JsonSyntaxException e) {
+                throw new TypeUpdateException("Invalid non-parseable JSON patch file in " + patchFile.getAbsolutePath());
+            }
+        }
+
+        LOG.info("Processed " + patchFiles.length + " patch files.");
+    }
+
+    private static Map<String, AtlasTypePatch> initializePatchHandlerMap(DefaultMetadataService metadataService, TypeSystem typeSystem) {
+        Map<String, AtlasTypePatch> patchHandlerMap = new HashMap<String, AtlasTypePatch>();
+        List<AtlasTypePatch> patchers = new ArrayList<AtlasTypePatch>();
+
+        // Register new patch classes here
+        patchers.add(new AtlasTypeAttributePatch(metadataService, typeSystem));
+
+        for (AtlasTypePatch patcher : patchers) {
+            for (String action : patcher.getSupportedActions()) {
+                patchHandlerMap.put(action, patcher);
+            }
+        }
+
+        return patchHandlerMap;
+    }
+
+    public static Gson initializeGson() {
+        GsonBuilder gsonBuilder = new GsonBuilder();
+        gsonBuilder.registerTypeAdapter(Multiplicity.class, new MultiplicityDeserializer());
+        gsonBuilder.setFieldNamingPolicy(FieldNamingPolicy.IDENTITY);
+        Gson gson = gsonBuilder.create();
+
+        return gson;
+    }
+
+    static class MultiplicityDeserializer implements JsonDeserializer<Multiplicity> {
+        @Override
+        public Multiplicity deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
+                throws JsonParseException {
+            String multiplicityString = json.getAsString().toLowerCase();
+            Multiplicity m = null;
+            switch (multiplicityString) {
+                case "optional":
+                    m = Multiplicity.OPTIONAL;
+                    break;
+                case "required":
+                    m = Multiplicity.REQUIRED;
+                    break;
+                case "collection":
+                    m = Multiplicity.COLLECTION;
+                    break;
+                case "set":
+                    m = Multiplicity.SET;
+                    break;
+                default:
+                    break;
+            }
+            return m;
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/repository/src/main/java/org/apache/atlas/services/AtlasTypeAttributePatch.java
----------------------------------------------------------------------
diff --git a/repository/src/main/java/org/apache/atlas/services/AtlasTypeAttributePatch.java b/repository/src/main/java/org/apache/atlas/services/AtlasTypeAttributePatch.java
new file mode 100644
index 0000000..b918c87
--- /dev/null
+++ b/repository/src/main/java/org/apache/atlas/services/AtlasTypeAttributePatch.java
@@ -0,0 +1,296 @@
+/**
+ * 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.services;
+
+
+import com.google.common.collect.ImmutableList;
+import org.apache.atlas.AtlasException;
+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.HierarchicalTypeDefinition;
+import org.apache.atlas.typesystem.types.IDataType;
+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.TypeSystem;
+import org.apache.atlas.typesystem.types.utils.TypesUtil;
+import org.codehaus.jettison.json.JSONException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+public class AtlasTypeAttributePatch extends AtlasTypePatch {
+
+    private static final Logger LOG = LoggerFactory.getLogger(AtlasTypeAttributePatch.class);
+    private static final String STRUCT_TYPE = "STRUCT";
+    private static final String CLASS_TYPE = "CLASS";
+    private static final String TRAIT_TYPE = "TRAIT";
+    private static final String[] SUPPORTED_ACTIONS = new String[] { "ADD_ATTRIBUTE", "UPDATE_ATTRIBUTE", "DELETE_ATTRIBUTE" };
+
+    public AtlasTypeAttributePatch(DefaultMetadataService metadataService, TypeSystem typeSystem) {
+        super(metadataService, typeSystem, SUPPORTED_ACTIONS);
+    }
+
+    /********* SAMPLE PATCH DATA ***********
+     *
+     *
+     {
+     "patches": [
+        {
+          "action": "ADD_ATTRIBUTE",
+          "typeName": "hive_column",
+          "applyToVersion": "1.0",
+          "updateToVersion": "2.0",
+          "params": {
+              "optionalParam1" : "true",
+              "optionalParam2" : "false"
+           },
+          "attributeDefinitions": [
+            {
+              "name": "position",
+              "dataTypeName": "string",
+              "multiplicity": "optional",
+              "isComposite": false,
+              "isUnique": false,
+              "isIndexable": false,
+              "reverseAttributeName": null
+            }
+          ]
+        }
+       ]
+     }
+     *
+     */
+
+    @Override
+    public PatchResult applyPatch(PatchData patchData) {
+        String typeName = patchData.getTypeName();
+        String applyVersion = patchData.getApplyToVersion();
+        TypesDef updatedTypeDef;
+        PatchResult result;
+        try {
+            // Check if type exists in type system
+            if (checkIfTypeExists(typeName, metadataService)) {
+                TypesDef typesDef = getTypeDef(typeName);
+                String currentVersion = getTypeVersion(typeName);
+
+                // Check version to apply patch
+                if (currentVersion == null || currentVersion.equalsIgnoreCase(applyVersion) || currentVersion.startsWith(applyVersion + ".")) {
+                    updatedTypeDef = updateTypesDef(typesDef, patchData);
+
+                    if (updatedTypeDef != null) {
+                        metadataService.updateType(TypesSerialization.toJson(updatedTypeDef));
+                        LOG.info("updated " + patchData.getTypeName() + " type from version " + patchData.getApplyToVersion() + " to " + patchData.getUpdateToVersion());
+                        result = new PatchResult("patch applied successfully!", PatchStatus.SUCCESS);
+                    } else {
+                        LOG.error("failed to create updated typedef for type=" +typeName+ "; applyToVersion=" + applyVersion + "; updateToVersion=" + patchData.getUpdateToVersion() );
+                        result = new PatchResult("patch failed!", PatchStatus.FAILED);
+                    }
+                } else {
+                    LOG.info("patch skipped for " + patchData.getTypeName());
+                    result = new PatchResult("patch skipped!", PatchStatus.SKIPPED);
+                }
+
+            } else {
+                LOG.error("failed to apply patch (typeName=" + typeName + "; applyToVersion=" + applyVersion + "; updateToVersion=" + patchData.getUpdateToVersion() + "): type doesn't exist");
+                result = new PatchResult("patch failed!", PatchStatus.FAILED);
+            }
+
+        } catch (AtlasException e) {
+            LOG.error("error in updating type for " + patchData.getTypeName());
+            result = new PatchResult("unable to update type", PatchStatus.FAILED);
+        } catch (JSONException e) {
+            LOG.error("error in updating typedef for  " + patchData.getTypeName());
+            result = new PatchResult("unable to update typedef", PatchStatus.FAILED);
+        }
+
+        return result;
+    }
+
+    public TypesDef updateTypesDef(TypesDef typesDef, PatchData patchData) throws AtlasException, JSONException {
+        AttributeDefinition[] typeAttributes = getAttributesFromTypesDef(typesDef, patchData.getTypeName());
+        AttributeDefinition[] patchAttributes = patchData.getAttributeDefinitions();
+        AttributeDefinition[] newAttributes = new AttributeDefinition[0];
+        String patchAction = patchData.getAction();
+        TypesDef newTypeDef = null;
+
+        if (patchAction != null && typeAttributes != null && patchAttributes != null) {
+            switch (patchAction) {
+                case "ADD_ATTRIBUTE":
+                    LOG.info("adding new attribute to type {}", patchData.getTypeName());
+                    newAttributes = addAttributes(typeAttributes, patchAttributes);
+                    break;
+                case "DELETE_ATTRIBUTE":
+                    LOG.info("deleting attribute from type {}", patchData.getTypeName());
+                    newAttributes = deleteAttributes(typeAttributes, patchAttributes);
+                    break;
+                case "UPDATE_ATTRIBUTE":
+                    LOG.info("updating attribute in type {}", patchData.getTypeName());
+                    newAttributes = updateAttributes(typeAttributes, patchAttributes);
+                    break;
+                default:
+                    LOG.info("invalid action " + patchAction + ", supported actions: " + Arrays.toString(SUPPORTED_ACTIONS));
+                    break;
+            }
+
+            newTypeDef = createTypeDefWithNewAttributes(typesDef, patchData.getTypeName(), newAttributes, patchData.getUpdateToVersion());
+        }
+
+        return newTypeDef;
+    }
+
+    private AttributeDefinition[] addAttributes(AttributeDefinition[] typeAttributes, AttributeDefinition[] patchAttributes) {
+        ArrayList<AttributeDefinition> newAttrList = new ArrayList<AttributeDefinition>(Arrays.asList(typeAttributes));
+        Map<String, AttributeDefinition> typeAttrs = getAttributeNamesFromDefinition(typeAttributes);
+
+        for (AttributeDefinition attr : patchAttributes) {
+            if (!typeAttrs.containsKey(attr.name))
+                newAttrList.add(attr);
+        }
+
+        return newAttrList.toArray(new AttributeDefinition[newAttrList.size()]);
+    }
+
+    private AttributeDefinition[] deleteAttributes(AttributeDefinition[] typeAttributes, AttributeDefinition[] patchAttributes) {
+        ArrayList<AttributeDefinition> newAttrList = new ArrayList<AttributeDefinition>();
+        Map<String, AttributeDefinition> patchAttrs = getAttributeNamesFromDefinition(patchAttributes);
+
+        for (AttributeDefinition attr : typeAttributes) {
+            if (!patchAttrs.containsKey(attr.name))
+                newAttrList.add(attr);
+        }
+
+        return newAttrList.toArray(new AttributeDefinition[newAttrList.size()]);
+    }
+
+    private AttributeDefinition[] updateAttributes(AttributeDefinition[] typeAttributes, AttributeDefinition[] patchAttributes) {
+        ArrayList<AttributeDefinition> newAttrList = new ArrayList<AttributeDefinition>();
+        Map<String, AttributeDefinition> patchAttrs = getAttributeNamesFromDefinition(patchAttributes);
+        AttributeDefinition newAttr;
+
+        for (AttributeDefinition attr : typeAttributes) {
+            newAttr = patchAttrs.get(attr.name);
+            if (patchAttrs.containsKey(attr.name) && checkIfAttributeUpdatable(attr, newAttr)) {
+                newAttrList.add(newAttr);
+            } else {
+                newAttrList.add(attr);
+            }
+        }
+
+        return newAttrList.toArray(new AttributeDefinition[newAttrList.size()]);
+    }
+
+    private TypesDef createTypeDefWithNewAttributes(TypesDef typesDef, String typeName, AttributeDefinition[] newAttributes, String newVersion) throws AtlasException {
+        ImmutableList.Builder<EnumTypeDefinition> enums = ImmutableList.builder();
+        ImmutableList.Builder<StructTypeDefinition> structs = ImmutableList.builder();
+        ImmutableList.Builder<HierarchicalTypeDefinition<ClassType>> classTypes = ImmutableList.builder();
+        ImmutableList.Builder<HierarchicalTypeDefinition<TraitType>> traits = ImmutableList.builder();
+        String dataType = getDataType(typeName).toUpperCase();
+        switch (dataType) {
+            case STRUCT_TYPE:
+                StructTypeDefinition structType = typesDef.structTypesAsJavaList().get(0);
+                structs.add(new StructTypeDefinition(structType.typeName, structType.typeDescription, newVersion, newAttributes));
+                break;
+            case CLASS_TYPE:
+                HierarchicalTypeDefinition<ClassType> classType = typesDef.classTypesAsJavaList().get(0);
+                classTypes.add(new HierarchicalTypeDefinition(ClassType.class, classType.typeName, classType.typeDescription, newVersion, classType.superTypes, newAttributes));
+                break;
+            case TRAIT_TYPE:
+                HierarchicalTypeDefinition<TraitType> traitType = typesDef.traitTypesAsJavaList().get(0);
+                traits.add(new HierarchicalTypeDefinition(TraitType.class, traitType.typeName, traitType.typeDescription, newVersion, traitType.superTypes, newAttributes));
+                break;
+            default:
+                LOG.error("unhandled datatype {} when creating new typedef", dataType);
+        }
+
+        return TypesUtil.getTypesDef(enums.build(), structs.build(), traits.build(), classTypes.build());
+    }
+
+    private AttributeDefinition[] getAttributesFromTypesDef(TypesDef typesDef, String typeName) throws AtlasException {
+        AttributeDefinition[] typeAttributes = null;
+        String dataType = getDataType(typeName).toUpperCase();
+        switch (dataType) {
+            case STRUCT_TYPE:
+                typeAttributes = typesDef.structTypesAsJavaList().get(0).attributeDefinitions;
+                break;
+            case CLASS_TYPE:
+                typeAttributes = typesDef.classTypesAsJavaList().get(0).attributeDefinitions;
+                break;
+            case TRAIT_TYPE:
+                typeAttributes = typesDef.traitTypesAsJavaList().get(0).attributeDefinitions;
+                break;
+            default:
+                LOG.error("unhandled datatype {}", dataType);
+        }
+
+        return typeAttributes;
+    }
+
+    private Map<String, AttributeDefinition> getAttributeNamesFromDefinition(AttributeDefinition[] attribDef) {
+        Map<String, AttributeDefinition> attrsMap = new HashMap<String, AttributeDefinition>();
+        for (AttributeDefinition attr : attribDef) {
+            attrsMap.put(attr.name, attr);
+        }
+
+        return attrsMap;
+    }
+
+    private boolean checkIfAttributeUpdatable(AttributeDefinition attr, AttributeDefinition newAttr) {
+        boolean result = false;
+        if (!attr.equals(newAttr) && (attr.multiplicity == Multiplicity.REQUIRED
+                && newAttr.multiplicity == Multiplicity.OPTIONAL)) {
+            result = true;
+        }
+
+        return result;
+    }
+
+    // Returns the datatype the typename belongs to - PRIMITIVE, ENUM, ARRAY, MAP, STRUCT, TRAIT, CLASS
+    private String getDataType(String typeName) throws AtlasException {
+        IDataType dataType = typeSystem.getDataType(IDataType.class, typeName);
+        return dataType.getTypeCategory().toString();
+    }
+
+    private String getTypeVersion(String typeName) throws AtlasException {
+        return typeSystem.getDataType(IDataType.class, typeName).getVersion();
+    }
+
+    private TypesDef getTypeDef(String typeName) throws AtlasException {
+        return TypesSerialization.fromJson(metadataService.getTypeDefinition(typeName));
+    }
+
+    private static boolean checkIfTypeExists(String typeName, DefaultMetadataService metadataService) {
+        boolean result = true;
+        try {
+            metadataService.getTypeDefinition(typeName);
+        } catch (AtlasException e) {
+            result = false;
+        }
+
+        return result;
+    }
+
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/repository/src/main/java/org/apache/atlas/services/AtlasTypePatch.java
----------------------------------------------------------------------
diff --git a/repository/src/main/java/org/apache/atlas/services/AtlasTypePatch.java b/repository/src/main/java/org/apache/atlas/services/AtlasTypePatch.java
new file mode 100644
index 0000000..0698efb
--- /dev/null
+++ b/repository/src/main/java/org/apache/atlas/services/AtlasTypePatch.java
@@ -0,0 +1,104 @@
+/**
+ * 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.services;
+
+
+import org.apache.atlas.typesystem.types.AttributeDefinition;
+import org.apache.atlas.typesystem.types.TypeSystem;
+
+import java.util.Map;
+
+
+public abstract class AtlasTypePatch {
+    protected final TypeSystem typeSystem;
+    protected final DefaultMetadataService metadataService;
+    protected final String[] supportedActions;
+
+    protected AtlasTypePatch(DefaultMetadataService metadataService, TypeSystem typeSystem, String[] supportedActions) {
+        this.metadataService = metadataService;
+        this.typeSystem = typeSystem;
+        this.supportedActions = supportedActions;
+    }
+
+    public final String[] getSupportedActions() { return supportedActions; }
+
+    public abstract PatchResult applyPatch(PatchData patch);
+
+    public enum PatchStatus { SUCCESS, FAILED, SKIPPED }
+
+    public class PatchResult {
+        private String message;
+        private PatchStatus status;
+
+        public PatchResult(String message, PatchStatus status) {
+            this.message = message;
+            this.status = status;
+        }
+
+        public String getMessage() { return message; }
+
+        public void setMessage(String message) { this.message = message; }
+
+        public PatchStatus getStatus() { return status; }
+
+        public void setStatus(PatchStatus status) { this.status = status; }
+
+    }
+
+    /**
+     * A class to capture patch content.
+     */
+    public class PatchContent {
+        private PatchData[] patches;
+
+        public PatchData[] getPatches() {
+            return patches;
+        }
+    }
+
+    public static class PatchData {
+        private String action;
+        private String typeName;
+        private String applyToVersion;
+        private String updateToVersion;
+        private Map<String, String> params;
+        private AttributeDefinition[] attributeDefinitions;
+
+        public PatchData(String action, String typeName, String applyToVersion, String updateToVersion, Map<String, String> params, AttributeDefinition[] attributeDefinitions) {
+            this.action = action;
+            this.typeName = typeName;
+            this.applyToVersion = applyToVersion;
+            this.updateToVersion = updateToVersion;
+            this.params = params;
+            this.attributeDefinitions = attributeDefinitions;
+        }
+
+        public String getAction() { return action; }
+
+        public String getTypeName() {  return typeName; }
+
+        public String getApplyToVersion() { return applyToVersion; }
+
+        public String getUpdateToVersion() { return updateToVersion; }
+
+        public Map<String, String> getParams() { return params; }
+
+        public AttributeDefinition[] getAttributeDefinitions() { return attributeDefinitions; }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/repository/src/main/java/org/apache/atlas/services/DefaultMetadataService.java
----------------------------------------------------------------------
diff --git a/repository/src/main/java/org/apache/atlas/services/DefaultMetadataService.java b/repository/src/main/java/org/apache/atlas/services/DefaultMetadataService.java
index 3550492..026e98c 100755
--- a/repository/src/main/java/org/apache/atlas/services/DefaultMetadataService.java
+++ b/repository/src/main/java/org/apache/atlas/services/DefaultMetadataService.java
@@ -153,6 +153,8 @@ public class DefaultMetadataService implements MetadataService, ActiveStateChang
             restoreTypeSystem();
         }
 
+        AtlasPatchHandler.handlePatches(this, typeSystem);
+
         maxAuditResults = configuration.getShort(CONFIG_MAX_AUDIT_RESULTS, DEFAULT_MAX_AUDIT_RESULTS);
     }
 

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/repository/src/test/java/org/apache/atlas/service/DefaultMetadataServiceTest.java
----------------------------------------------------------------------
diff --git a/repository/src/test/java/org/apache/atlas/service/DefaultMetadataServiceTest.java b/repository/src/test/java/org/apache/atlas/service/DefaultMetadataServiceTest.java
index 6782970..e713ba5 100644
--- a/repository/src/test/java/org/apache/atlas/service/DefaultMetadataServiceTest.java
+++ b/repository/src/test/java/org/apache/atlas/service/DefaultMetadataServiceTest.java
@@ -36,6 +36,10 @@ import org.apache.atlas.repository.audit.EntityAuditRepository;
 import org.apache.atlas.repository.audit.HBaseBasedAuditRepository;
 import org.apache.atlas.repository.audit.HBaseTestUtils;
 import org.apache.atlas.repository.graph.GraphProvider;
+import org.apache.atlas.services.AtlasTypeAttributePatch;
+import org.apache.atlas.services.AtlasTypePatch;
+import org.apache.atlas.services.AtlasTypePatch.PatchData;
+import org.apache.atlas.services.DefaultMetadataService;
 import org.apache.atlas.services.MetadataService;
 import org.apache.atlas.typesystem.IReferenceableInstance;
 import org.apache.atlas.typesystem.IStruct;
@@ -111,7 +115,6 @@ public class DefaultMetadataServiceTest {
     private Referenceable table;
 
     private Id tableId;
-    
     private final String NAME = "name";
 
 
@@ -1092,6 +1095,43 @@ public class DefaultMetadataServiceTest {
     }
 
     @Test
+    public void testPatchFrameworkForTypeUpdate() throws AtlasException, JSONException {
+        String typeName = "test_type_" + RandomStringUtils.randomAlphanumeric(10);
+        HierarchicalTypeDefinition<ClassType> typeDef = TypesUtil.createClassTypeDef(typeName, ImmutableSet.<String>of(),
+                TypesUtil.createUniqueRequiredAttrDef("type_attr1", DataTypes.STRING_TYPE));
+
+        TypesDef typesDef = new TypesDef(typeDef, false);
+        metadataService.createType(TypesSerialization.toJson(typesDef));
+
+        AtlasTypeAttributePatch patch = new AtlasTypeAttributePatch((DefaultMetadataService) metadataService, TypeSystem.getInstance());
+        AttributeDefinition[] attrDefs = new AttributeDefinition[]{
+                new AttributeDefinition("type_attr2", DataTypes.STRING_TYPE.getName(), Multiplicity.OPTIONAL, false, null),
+                new AttributeDefinition("type_attr3", DataTypes.STRING_TYPE.getName(), Multiplicity.OPTIONAL, false, null)};
+
+        // Testing add attribute patch
+        AtlasTypePatch.PatchData addAttributePatch = new PatchData("ADD_ATTRIBUTE", typeName, "1.0", "2.0", null, attrDefs);
+        TypesDef newAttrTypesDef = patch.updateTypesDef(typesDef, addAttributePatch);
+        metadataService.updateType(TypesSerialization.toJson(newAttrTypesDef));
+        TypesDef addedTypesDef = TypesSerialization.fromJson(metadataService.getTypeDefinition(typeName));
+
+        // test added attributes and update version to 2.0
+        assertEquals(addedTypesDef.classTypes().head().attributeDefinitions.length, 3);
+        assertEquals(addedTypesDef.classTypes().head().typeVersion, "2.0");
+
+        // Testing update attribute patch
+        AttributeDefinition[] updateAttrDef = new AttributeDefinition[]{
+                new AttributeDefinition("type_attr1", DataTypes.STRING_TYPE.getName(), Multiplicity.OPTIONAL, false, null)};
+        AtlasTypePatch.PatchData updateAttributePatch = new PatchData("UPDATE_ATTRIBUTE", typeName, "2.0", "3.0", null, updateAttrDef);
+        TypesDef updateAttrTypesDef = patch.updateTypesDef(addedTypesDef, updateAttributePatch);
+        metadataService.updateType(TypesSerialization.toJson(updateAttrTypesDef));
+        TypesDef updatedTypesDef = TypesSerialization.fromJson(metadataService.getTypeDefinition(typeName));
+
+        // test update attribute to optional and update version to 3.0
+        assertEquals(updatedTypesDef.classTypes().head().attributeDefinitions[0].multiplicity, Multiplicity.OPTIONAL);
+        assertEquals(updatedTypesDef.classTypes().head().typeVersion, "3.0");
+    }
+
+    @Test
     public void testAuditEventsInvalidParams() throws Exception {
         //entity id can't be null
         try {
@@ -1178,7 +1218,7 @@ public class DefaultMetadataServiceTest {
                 deletedEntities.add(entity.getId()._getId());
             }
         }
-        
+
         public List<String> getDeletedEntities() {
             return deletedEntities;
         }

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/typesystem/src/main/java/org/apache/atlas/typesystem/types/AbstractDataType.java
----------------------------------------------------------------------
diff --git a/typesystem/src/main/java/org/apache/atlas/typesystem/types/AbstractDataType.java b/typesystem/src/main/java/org/apache/atlas/typesystem/types/AbstractDataType.java
index fad091d..874138b 100755
--- a/typesystem/src/main/java/org/apache/atlas/typesystem/types/AbstractDataType.java
+++ b/typesystem/src/main/java/org/apache/atlas/typesystem/types/AbstractDataType.java
@@ -20,6 +20,7 @@ package org.apache.atlas.typesystem.types;
 
 import com.google.common.collect.ImmutableSortedMap;
 
+import org.apache.atlas.AtlasConstants;
 import org.apache.atlas.AtlasException;
 
 import java.io.IOException;
@@ -30,12 +31,22 @@ abstract class AbstractDataType<T> implements IDataType<T> {
 
     public final String name;
     public final String description;
-    
+    public final String version;
+
     public AbstractDataType(String name, String description) {
 
         super();
         this.name = name;
         this.description = description;
+        this.version = AtlasConstants.DEFAULT_TYPE_VERSION;
+    }
+
+    public AbstractDataType(String name, String description, String version) {
+
+        super();
+        this.name = name;
+        this.description = description;
+        this.version = version;
     }
 
     protected T convertNull(Multiplicity m) throws AtlasException {
@@ -99,5 +110,10 @@ abstract class AbstractDataType<T> implements IDataType<T> {
     public String getDescription() {
         return description;
     }
+
+    @Override
+    public String getVersion() {
+        return version;
+    }
 }
 

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/typesystem/src/main/java/org/apache/atlas/typesystem/types/ClassType.java
----------------------------------------------------------------------
diff --git a/typesystem/src/main/java/org/apache/atlas/typesystem/types/ClassType.java b/typesystem/src/main/java/org/apache/atlas/typesystem/types/ClassType.java
index c56987a..6b530a8 100755
--- a/typesystem/src/main/java/org/apache/atlas/typesystem/types/ClassType.java
+++ b/typesystem/src/main/java/org/apache/atlas/typesystem/types/ClassType.java
@@ -23,6 +23,7 @@ import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 
+import org.apache.atlas.AtlasConstants;
 import org.apache.atlas.AtlasException;
 import org.apache.atlas.typesystem.IReferenceableInstance;
 import org.apache.atlas.typesystem.IStruct;
@@ -51,13 +52,22 @@ public class ClassType extends HierarchicalType<ClassType, IReferenceableInstanc
     public final Map<AttributeInfo, List<String>> infoToNameMap;
 
     ClassType(TypeSystem typeSystem, String name, String description, ImmutableSet<String> superTypes, int numFields) {
-        super(typeSystem, ClassType.class, name, description, superTypes, numFields);
+        this(typeSystem, name, description, AtlasConstants.DEFAULT_TYPE_VERSION, superTypes, numFields);
+    }
+
+    ClassType(TypeSystem typeSystem, String name, String description, String version, ImmutableSet<String> superTypes, int numFields) {
+        super(typeSystem, ClassType.class, name, description, version, superTypes, numFields);
         infoToNameMap = null;
     }
 
     ClassType(TypeSystem typeSystem, String name, String description, ImmutableSet<String> superTypes, AttributeInfo... fields)
     throws AtlasException {
-        super(typeSystem, ClassType.class, name, description, superTypes, fields);
+        this(typeSystem, name, description, AtlasConstants.DEFAULT_TYPE_VERSION, superTypes, fields);
+    }
+
+    ClassType(TypeSystem typeSystem, String name, String description, String version, ImmutableSet<String> superTypes, AttributeInfo... fields)
+            throws AtlasException {
+        super(typeSystem, ClassType.class, name, description, version, superTypes, fields);
         infoToNameMap = TypeUtils.buildAttrInfoToNameMap(fieldMapping);
     }
 

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/typesystem/src/main/java/org/apache/atlas/typesystem/types/EnumType.java
----------------------------------------------------------------------
diff --git a/typesystem/src/main/java/org/apache/atlas/typesystem/types/EnumType.java b/typesystem/src/main/java/org/apache/atlas/typesystem/types/EnumType.java
index bdd0a13..82e22ce 100755
--- a/typesystem/src/main/java/org/apache/atlas/typesystem/types/EnumType.java
+++ b/typesystem/src/main/java/org/apache/atlas/typesystem/types/EnumType.java
@@ -20,6 +20,7 @@ package org.apache.atlas.typesystem.types;
 
 import com.google.common.collect.ImmutableCollection;
 import com.google.common.collect.ImmutableMap;
+import org.apache.atlas.AtlasConstants;
 import org.apache.atlas.AtlasException;
 import scala.math.BigInt;
 
@@ -33,11 +34,15 @@ public class EnumType extends AbstractDataType<EnumValue> {
     public final ImmutableMap<Integer, EnumValue> ordinalMap;
 
     protected EnumType(TypeSystem typeSystem, String name, EnumValue... values) {
-       this(typeSystem, name, null, values);
+        this(typeSystem, name, null, values);
     }
 
     protected EnumType(TypeSystem typeSystem, String name, String description, EnumValue... values) {
-        super(name, description);
+        this(typeSystem, name, description, AtlasConstants.DEFAULT_TYPE_VERSION, values);
+    }
+
+    protected EnumType(TypeSystem typeSystem, String name, String description, String version, EnumValue... values) {
+        super(name, description, version);
         this.typeSystem = typeSystem;
         ImmutableMap.Builder<String, EnumValue> b1 = new ImmutableMap.Builder();
         ImmutableMap.Builder<Integer, EnumValue> b2 = new ImmutableMap.Builder();

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/typesystem/src/main/java/org/apache/atlas/typesystem/types/EnumTypeDefinition.java
----------------------------------------------------------------------
diff --git a/typesystem/src/main/java/org/apache/atlas/typesystem/types/EnumTypeDefinition.java b/typesystem/src/main/java/org/apache/atlas/typesystem/types/EnumTypeDefinition.java
index 6340615..ac3b5a3 100755
--- a/typesystem/src/main/java/org/apache/atlas/typesystem/types/EnumTypeDefinition.java
+++ b/typesystem/src/main/java/org/apache/atlas/typesystem/types/EnumTypeDefinition.java
@@ -19,6 +19,7 @@
 package org.apache.atlas.typesystem.types;
 
 import org.apache.atlas.utils.ParamChecker;
+import org.apache.atlas.AtlasConstants;
 
 import java.util.Arrays;
 
@@ -26,16 +27,22 @@ public final class EnumTypeDefinition {
 
     public final String name;
     public final String description;
+    public final String version;
     public final EnumValue[] enumValues;
 
     public EnumTypeDefinition(String name, EnumValue... enumValues) {
-        this(name, null, enumValues);
+        this(name, null, AtlasConstants.DEFAULT_TYPE_VERSION, enumValues);
     }
 
     public EnumTypeDefinition(String name, String description, EnumValue... enumValues) {
+        this(name, description, AtlasConstants.DEFAULT_TYPE_VERSION, enumValues);
+    }
+
+    public EnumTypeDefinition(String name, String description, String version, EnumValue... enumValues) {
         this.name = ParamChecker.notEmpty(name, "Enum type name");
         this.description = description;
         this.enumValues = ParamChecker.notNullElements(enumValues, "Enum values");
+        this.version = version;
     }
 
     @Override

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/typesystem/src/main/java/org/apache/atlas/typesystem/types/HierarchicalType.java
----------------------------------------------------------------------
diff --git a/typesystem/src/main/java/org/apache/atlas/typesystem/types/HierarchicalType.java b/typesystem/src/main/java/org/apache/atlas/typesystem/types/HierarchicalType.java
index 7224699..392d2bf 100755
--- a/typesystem/src/main/java/org/apache/atlas/typesystem/types/HierarchicalType.java
+++ b/typesystem/src/main/java/org/apache/atlas/typesystem/types/HierarchicalType.java
@@ -23,6 +23,7 @@ import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.UnmodifiableIterator;
 
+import org.apache.atlas.AtlasConstants;
 import org.apache.atlas.AtlasException;
 import org.apache.atlas.typesystem.IStruct;
 import org.apache.atlas.typesystem.persistence.DownCastStructInstance;
@@ -70,7 +71,12 @@ public abstract class HierarchicalType<ST extends HierarchicalType, T> extends A
      */
     HierarchicalType(TypeSystem typeSystem, Class<ST> superTypeClass, String name, String description, ImmutableSet<String> superTypes,
             int numFields) {
-        super(name, description);
+        this( typeSystem, superTypeClass, name, description, AtlasConstants.DEFAULT_TYPE_VERSION, superTypes, numFields);
+    }
+
+    HierarchicalType(TypeSystem typeSystem, Class<ST> superTypeClass, String name, String description, String version, ImmutableSet<String> superTypes,
+                     int numFields) {
+        super(name, description, version);
         this.typeSystem = typeSystem;
         this.superTypeClass = superTypeClass;
         this.fieldMapping = null;
@@ -86,7 +92,12 @@ public abstract class HierarchicalType<ST extends HierarchicalType, T> extends A
     }
     HierarchicalType(TypeSystem typeSystem, Class<ST> superTypeClass, String name, String description, ImmutableSet<String> superTypes,
             AttributeInfo... fields) throws AtlasException {
-        super(name, description);
+        this(typeSystem, superTypeClass, name, description, AtlasConstants.DEFAULT_TYPE_VERSION, superTypes, fields);
+    }
+
+    HierarchicalType(TypeSystem typeSystem, Class<ST> superTypeClass, String name, String description, String version, ImmutableSet<String> superTypes,
+                     AttributeInfo... fields) throws AtlasException {
+        super(name, description, version);
         this.typeSystem = typeSystem;
         this.superTypeClass = superTypeClass;
         Pair<FieldMapping, ImmutableMap<String, String>> p = constructFieldMapping(superTypes, fields);

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/typesystem/src/main/java/org/apache/atlas/typesystem/types/HierarchicalTypeDefinition.java
----------------------------------------------------------------------
diff --git a/typesystem/src/main/java/org/apache/atlas/typesystem/types/HierarchicalTypeDefinition.java b/typesystem/src/main/java/org/apache/atlas/typesystem/types/HierarchicalTypeDefinition.java
index 9a299f0..8069422 100755
--- a/typesystem/src/main/java/org/apache/atlas/typesystem/types/HierarchicalTypeDefinition.java
+++ b/typesystem/src/main/java/org/apache/atlas/typesystem/types/HierarchicalTypeDefinition.java
@@ -21,34 +21,41 @@ package org.apache.atlas.typesystem.types;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 
+import org.apache.atlas.AtlasConstants;
 import org.apache.atlas.classification.InterfaceAudience;
+import org.apache.atlas.utils.ParamChecker;
 
 public class HierarchicalTypeDefinition<T extends HierarchicalType> extends StructTypeDefinition {
 
     public final ImmutableSet<String> superTypes;
     public final String hierarchicalMetaTypeName;
 
-    /**
-     * Used for json deserialization only.
-     * not intended public consumption
-     * @param hierarchicalMetaTypeName
-     * @param typeName
-     * @param typeDescription
-     * @param superTypes
-     * @param attributeDefinitions
-     * @throws ClassNotFoundException
-     */
-    @InterfaceAudience.Private
-    public HierarchicalTypeDefinition(String hierarchicalMetaTypeName, String typeName, String typeDescription, String[] superTypes,
-            AttributeDefinition[] attributeDefinitions) throws ClassNotFoundException {
-        this((Class<T>) Class.forName(hierarchicalMetaTypeName), typeName, typeDescription, ImmutableSet.copyOf(superTypes),
+    public HierarchicalTypeDefinition(Class<T> hierarchicalMetaType, String typeName, String typeDescription, ImmutableSet<String> superTypes,
+            AttributeDefinition[] attributeDefinitions) {
+        this(hierarchicalMetaType, typeName, typeDescription, AtlasConstants.DEFAULT_TYPE_VERSION, superTypes,
                 attributeDefinitions);
     }
 
-    public HierarchicalTypeDefinition(Class<T> hierarchicalMetaType, String typeName, String typeDescription, ImmutableSet<String> superTypes,
-        AttributeDefinition[] attributeDefinitions) {
-        super(typeName, typeDescription, false, attributeDefinitions);
-        hierarchicalMetaTypeName = hierarchicalMetaType.getName();
+    // Used only for de-serializing JSON String to typedef.
+    public HierarchicalTypeDefinition( String hierarchicalMetaTypeName, String typeName, String typeDescription, String typeVersion, String[] superTypes, AttributeDefinition[] attributeDefinitions) throws ClassNotFoundException {
+        this((Class<T>) Class.forName(hierarchicalMetaTypeName), typeName, typeDescription, typeVersion, ImmutableSet.copyOf(superTypes), attributeDefinitions);
+    }
+    // Used only for de-serializing JSON String to typedef (no typeVersion).
+    public HierarchicalTypeDefinition( String hierarchicalMetaTypeName, String typeName, String typeDescription, String[] superTypes, AttributeDefinition[] attributeDefinitions) throws ClassNotFoundException {
+        this((Class<T>) Class.forName(hierarchicalMetaTypeName), typeName, typeDescription, AtlasConstants.DEFAULT_TYPE_VERSION, ImmutableSet.copyOf(superTypes), attributeDefinitions);
+    }
+    // Used only for serializing typedef to JSON String.
+    public HierarchicalTypeDefinition( String hierarchicalMetaTypeName, String typeName, String typeDescription, String typeVersion, ImmutableSet<String> superTypes, AttributeDefinition[] attributeDefinitions, String typeDef) throws ClassNotFoundException {
+        this((Class<T>) Class.forName(hierarchicalMetaTypeName), typeName, typeDescription, typeVersion, superTypes, attributeDefinitions);
+    }
+    // Used only for serializing typedef to JSON String (no typeVersion).
+    public HierarchicalTypeDefinition( String hierarchicalMetaTypeName, String typeName, String typeDescription, ImmutableSet<String> superTypes, AttributeDefinition[] attributeDefinitions, String typeDef) throws ClassNotFoundException {
+        this((Class<T>) Class.forName(hierarchicalMetaTypeName), typeName, typeDescription, AtlasConstants.DEFAULT_TYPE_VERSION, superTypes, attributeDefinitions);
+    }
+
+    public HierarchicalTypeDefinition(Class<T> hierarchicalMetaType, String typeName, String typeDescription, String typeVersion, ImmutableSet<String> superTypes, AttributeDefinition[] attributeDefinitions) {
+        super(typeName, typeDescription, typeVersion, false, attributeDefinitions);
+        this.hierarchicalMetaTypeName = hierarchicalMetaType.getName();
         this.superTypes = superTypes == null ? ImmutableSet.<String>of() : superTypes;
     }
 

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/typesystem/src/main/java/org/apache/atlas/typesystem/types/IDataType.java
----------------------------------------------------------------------
diff --git a/typesystem/src/main/java/org/apache/atlas/typesystem/types/IDataType.java b/typesystem/src/main/java/org/apache/atlas/typesystem/types/IDataType.java
index 85ddee7..a7a2123 100755
--- a/typesystem/src/main/java/org/apache/atlas/typesystem/types/IDataType.java
+++ b/typesystem/src/main/java/org/apache/atlas/typesystem/types/IDataType.java
@@ -55,5 +55,7 @@ public interface IDataType<T> {
     void updateSignatureHash(MessageDigest digester, Object val) throws AtlasException;
 
     String getDescription();
+
+    String getVersion();
 }
 

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/typesystem/src/main/java/org/apache/atlas/typesystem/types/StructType.java
----------------------------------------------------------------------
diff --git a/typesystem/src/main/java/org/apache/atlas/typesystem/types/StructType.java b/typesystem/src/main/java/org/apache/atlas/typesystem/types/StructType.java
index 6f40c1d..5d25730 100755
--- a/typesystem/src/main/java/org/apache/atlas/typesystem/types/StructType.java
+++ b/typesystem/src/main/java/org/apache/atlas/typesystem/types/StructType.java
@@ -29,6 +29,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
+import org.apache.atlas.AtlasConstants;
 import org.apache.atlas.AtlasException;
 import org.apache.atlas.typesystem.IStruct;
 import org.apache.atlas.typesystem.ITypedStruct;
@@ -42,7 +43,11 @@ public class StructType extends AbstractDataType<IStruct> implements IConstructa
     private final TypedStructHandler handler;
 
     protected StructType(TypeSystem typeSystem, String name, String description, int numFields) {
-        super(name, description);
+        this(typeSystem, name, description, AtlasConstants.DEFAULT_TYPE_VERSION, numFields);
+    }
+
+    protected StructType(TypeSystem typeSystem, String name, String description, String version, int numFields) {
+        super(name, description, version);
         this.typeSystem = typeSystem;
         this.fieldMapping = null;
         infoToNameMap = null;
@@ -52,7 +57,12 @@ public class StructType extends AbstractDataType<IStruct> implements IConstructa
 
     protected StructType(TypeSystem typeSystem, String name, String description, AttributeInfo... fields)
     throws AtlasException {
-        super(name, description);
+        this(typeSystem, name, description, AtlasConstants.DEFAULT_TYPE_VERSION, fields);
+    }
+
+    protected StructType(TypeSystem typeSystem, String name, String description, String version, AttributeInfo... fields)
+            throws AtlasException {
+        super(name, description, version);
         this.typeSystem = typeSystem;
         this.fieldMapping = constructFieldMapping(fields);
         infoToNameMap = TypeUtils.buildAttrInfoToNameMap(this.fieldMapping);

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/typesystem/src/main/java/org/apache/atlas/typesystem/types/StructTypeDefinition.java
----------------------------------------------------------------------
diff --git a/typesystem/src/main/java/org/apache/atlas/typesystem/types/StructTypeDefinition.java b/typesystem/src/main/java/org/apache/atlas/typesystem/types/StructTypeDefinition.java
index f1ce1b7..c9316cc 100755
--- a/typesystem/src/main/java/org/apache/atlas/typesystem/types/StructTypeDefinition.java
+++ b/typesystem/src/main/java/org/apache/atlas/typesystem/types/StructTypeDefinition.java
@@ -18,6 +18,7 @@
 
 package org.apache.atlas.typesystem.types;
 
+import org.apache.atlas.AtlasConstants;
 import org.apache.atlas.utils.ParamChecker;
 
 import java.util.Arrays;
@@ -26,29 +27,45 @@ public class StructTypeDefinition {
 
     public final String typeName;
     public final String typeDescription;//optional field
+    public final String typeVersion;
     public final AttributeDefinition[] attributeDefinitions;
 
     protected StructTypeDefinition(String typeName, String typeDescription, boolean validate,
                                    AttributeDefinition... attributeDefinitions) {
+        this(typeName, typeDescription, AtlasConstants.DEFAULT_TYPE_VERSION, validate, attributeDefinitions);
+    }
+
+    protected StructTypeDefinition(String typeName, String typeDescription, String typeVersion, boolean validate,
+                                   AttributeDefinition... attributeDefinitions) {
         this.typeName = ParamChecker.notEmpty(typeName, "Struct type name");
         this.typeDescription = typeDescription;
         if (validate) {
             ParamChecker.notNullElements(attributeDefinitions, "Attribute definitions");
         }
         this.attributeDefinitions = attributeDefinitions;
+        this.typeVersion = typeVersion;
     }
 
     public StructTypeDefinition(String typeName, AttributeDefinition[] attributeDefinitions) {
-        this(typeName, null, attributeDefinitions);
+        this(typeName, null, AtlasConstants.DEFAULT_TYPE_VERSION,  attributeDefinitions);
     }
 
     public StructTypeDefinition(String typeName, String typeDescription,
         AttributeDefinition[] attributeDefinitions) {
+
+        this(typeName, typeDescription, AtlasConstants.DEFAULT_TYPE_VERSION,  attributeDefinitions);
+    }
+
+    public StructTypeDefinition(String typeName, String typeDescription, String typeVersion,
+                                AttributeDefinition[] attributeDefinitions) {
         this.typeName = ParamChecker.notEmpty(typeName, "Struct type name");
         this.typeDescription = typeDescription;
+        this.typeVersion = typeVersion;
         this.attributeDefinitions = ParamChecker.notNullElements(attributeDefinitions, "Attribute definitions");
     }
 
+
+
     @Override
     public boolean equals(Object o) {
         if (this == o) {

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/typesystem/src/main/java/org/apache/atlas/typesystem/types/TraitType.java
----------------------------------------------------------------------
diff --git a/typesystem/src/main/java/org/apache/atlas/typesystem/types/TraitType.java b/typesystem/src/main/java/org/apache/atlas/typesystem/types/TraitType.java
index f23bf5b..bbb845a 100755
--- a/typesystem/src/main/java/org/apache/atlas/typesystem/types/TraitType.java
+++ b/typesystem/src/main/java/org/apache/atlas/typesystem/types/TraitType.java
@@ -20,6 +20,7 @@ package org.apache.atlas.typesystem.types;
 
 import com.google.common.collect.ImmutableSet;
 
+import org.apache.atlas.AtlasConstants;
 import org.apache.atlas.AtlasException;
 import org.apache.atlas.typesystem.IStruct;
 import org.apache.atlas.typesystem.ITypedStruct;
@@ -37,14 +38,23 @@ public class TraitType extends HierarchicalType<TraitType, IStruct>
     private final TypedStructHandler handler;
 
     TraitType(TypeSystem typeSystem, String name, String description, ImmutableSet<String> superTraits, int numFields) {
-        super(typeSystem, TraitType.class, name, description, superTraits, numFields);
+        this(typeSystem, name, description, AtlasConstants.DEFAULT_TYPE_VERSION, superTraits, numFields);
+    }
+
+    TraitType(TypeSystem typeSystem, String name, String description, String version, ImmutableSet<String> superTraits, int numFields) {
+        super(typeSystem, TraitType.class, name, description, version, superTraits, numFields);
         handler = null;
         infoToNameMap = null;
     }
 
     TraitType(TypeSystem typeSystem, String name, String description, ImmutableSet<String> superTraits, AttributeInfo... fields)
     throws AtlasException {
-        super(typeSystem, TraitType.class, name, description, superTraits, fields);
+        this(typeSystem, name, description, AtlasConstants.DEFAULT_TYPE_VERSION, superTraits, fields);
+    }
+
+    TraitType(TypeSystem typeSystem, String name, String description, String version, ImmutableSet<String> superTraits, AttributeInfo... fields)
+            throws AtlasException {
+        super(typeSystem, TraitType.class, name, description, version, superTraits, fields);
         handler = new TypedStructHandler(this);
         infoToNameMap = TypeUtils.buildAttrInfoToNameMap(fieldMapping);
     }

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/typesystem/src/main/java/org/apache/atlas/typesystem/types/TypeSystem.java
----------------------------------------------------------------------
diff --git a/typesystem/src/main/java/org/apache/atlas/typesystem/types/TypeSystem.java b/typesystem/src/main/java/org/apache/atlas/typesystem/types/TypeSystem.java
index 70ba89b..52637e6 100755
--- a/typesystem/src/main/java/org/apache/atlas/typesystem/types/TypeSystem.java
+++ b/typesystem/src/main/java/org/apache/atlas/typesystem/types/TypeSystem.java
@@ -311,7 +311,7 @@ public class TypeSystem {
             throw new AtlasException(String.format("Redefinition of type %s not supported", eDef.name));
         }
 
-        EnumType eT = new EnumType(this, eDef.name, eDef.description, eDef.enumValues);
+        EnumType eT = new EnumType(this, eDef.name, eDef.description, eDef.version, eDef.enumValues);
         typeCache.put(eT);
         return eT;
     }
@@ -408,7 +408,7 @@ public class TypeSystem {
                     throw new AtlasException(String.format("Redefinition of type %s not supported", eDef.name));
                 }
 
-                EnumType eT = new EnumType(this, eDef.name, eDef.description, eDef.enumValues);
+                EnumType eT = new EnumType(this, eDef.name, eDef.description, eDef.version, eDef.enumValues);
                 transientTypes.put(eDef.name, eT);
             }
 
@@ -417,7 +417,7 @@ public class TypeSystem {
                 if (!update && isRegistered(sDef.typeName)) {
                     throw new TypeExistsException(String.format("Cannot redefine type %s", sDef.typeName));
                 }
-                StructType sT = new StructType(this, sDef.typeName, sDef.typeDescription, sDef.attributeDefinitions.length);
+                StructType sT = new StructType(this, sDef.typeName, sDef.typeDescription, sDef.typeVersion, sDef.attributeDefinitions.length);
                 structNameToDefMap.put(sDef.typeName, sDef);
                 transientTypes.put(sDef.typeName, sT);
             }
@@ -427,7 +427,7 @@ public class TypeSystem {
                 if (!update && isRegistered(traitDef.typeName)) {
                     throw new TypeExistsException(String.format("Cannot redefine type %s", traitDef.typeName));
                 }
-                TraitType tT = new TraitType(this, traitDef.typeName, traitDef.typeDescription, traitDef.superTypes,
+                TraitType tT = new TraitType(this, traitDef.typeName, traitDef.typeDescription, traitDef.typeVersion, traitDef.superTypes,
                         traitDef.attributeDefinitions.length);
                 traitNameToDefMap.put(traitDef.typeName, traitDef);
                 transientTypes.put(traitDef.typeName, tT);
@@ -439,7 +439,7 @@ public class TypeSystem {
                     throw new TypeExistsException(String.format("Cannot redefine type %s", classDef.typeName));
                 }
 
-                ClassType cT = new ClassType(this, classDef.typeName, classDef.typeDescription, classDef.superTypes,
+                ClassType cT = new ClassType(this, classDef.typeName, classDef.typeDescription, classDef.typeVersion, classDef.superTypes,
                         classDef.attributeDefinitions.length);
                 classNameToDefMap.put(classDef.typeName, classDef);
                 transientTypes.put(classDef.typeName, cT);
@@ -526,7 +526,7 @@ public class TypeSystem {
                 infos[i] = constructAttributeInfo(def.attributeDefinitions[i]);
             }
 
-            StructType type = new StructType(this, def.typeName, def.typeDescription, infos);
+            StructType type = new StructType(this, def.typeName, def.typeDescription, def.typeVersion, infos);
             transientTypes.put(def.typeName, type);
             return type;
         }
@@ -539,9 +539,9 @@ public class TypeSystem {
             }
 
             try {
-                Constructor<U> cons = cls.getDeclaredConstructor(TypeSystem.class, String.class, String.class, ImmutableSet.class,
+                Constructor<U> cons = cls.getDeclaredConstructor(TypeSystem.class, String.class, String.class, String.class, ImmutableSet.class,
                         AttributeInfo[].class);
-                U type = cons.newInstance(this, def.typeName, def.typeDescription, def.superTypes, infos);
+                U type = cons.newInstance(this, def.typeName, def.typeDescription, def.typeVersion, def.superTypes, infos);
                 transientTypes.put(def.typeName, type);
                 return type;
             } catch (Exception e) {

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/typesystem/src/main/java/org/apache/atlas/typesystem/types/utils/TypesUtil.java
----------------------------------------------------------------------
diff --git a/typesystem/src/main/java/org/apache/atlas/typesystem/types/utils/TypesUtil.java b/typesystem/src/main/java/org/apache/atlas/typesystem/types/utils/TypesUtil.java
index ef8448d..77cbd39 100755
--- a/typesystem/src/main/java/org/apache/atlas/typesystem/types/utils/TypesUtil.java
+++ b/typesystem/src/main/java/org/apache/atlas/typesystem/types/utils/TypesUtil.java
@@ -33,6 +33,7 @@ import org.apache.atlas.typesystem.types.IDataType;
 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.AtlasConstants;
 
 import org.apache.atlas.typesystem.types.TypeSystem;
 import scala.collection.JavaConversions;
@@ -76,6 +77,11 @@ public class TypesUtil {
 
     public static HierarchicalTypeDefinition<TraitType> createTraitTypeDef(String name, String description,
         ImmutableSet<String> superTypes, AttributeDefinition... attrDefs) {
+        return createTraitTypeDef(name, description, AtlasConstants.DEFAULT_TYPE_VERSION, superTypes, attrDefs);
+    }
+
+    public static HierarchicalTypeDefinition<TraitType> createTraitTypeDef(String name, String description, String version,
+        ImmutableSet<String> superTypes, AttributeDefinition... attrDefs) {
         return new HierarchicalTypeDefinition<>(TraitType.class, name, description, superTypes, attrDefs);
     }
 
@@ -94,6 +100,11 @@ public class TypesUtil {
 
     public static HierarchicalTypeDefinition<ClassType> createClassTypeDef(String name, String description,
         ImmutableSet<String> superTypes, AttributeDefinition... attrDefs) {
+        return createClassTypeDef(name, description, AtlasConstants.DEFAULT_TYPE_VERSION, superTypes, attrDefs);
+    }
+
+    public static HierarchicalTypeDefinition<ClassType> createClassTypeDef(String name, String description, String version,
+        ImmutableSet<String> superTypes, AttributeDefinition... attrDefs) {
         return new HierarchicalTypeDefinition<>(ClassType.class, name, description, superTypes, attrDefs);
     }
 

http://git-wip-us.apache.org/repos/asf/incubator-atlas/blob/180c6e57/typesystem/src/main/scala/org/apache/atlas/typesystem/json/TypesSerialization.scala
----------------------------------------------------------------------
diff --git a/typesystem/src/main/scala/org/apache/atlas/typesystem/json/TypesSerialization.scala b/typesystem/src/main/scala/org/apache/atlas/typesystem/json/TypesSerialization.scala
index 5618938..4478a44 100755
--- a/typesystem/src/main/scala/org/apache/atlas/typesystem/json/TypesSerialization.scala
+++ b/typesystem/src/main/scala/org/apache/atlas/typesystem/json/TypesSerialization.scala
@@ -21,6 +21,7 @@ package org.apache.atlas.typesystem.json
 import java.text.SimpleDateFormat
 import com.google.common.collect.ImmutableList
 import org.apache.atlas.AtlasException
+import org.apache.atlas.AtlasConstants
 import org.apache.atlas.typesystem.TypesDef
 import org.apache.atlas.typesystem.types.DataTypes.{ArrayType, MapType, TypeCategory}
 import org.apache.atlas.typesystem.types._
@@ -131,28 +132,28 @@ object TypesSerialization {
 
     private def convertEnumTypeToEnumTypeDef(et: EnumType) = {
         val eVals: Seq[EnumValue] = et.valueMap.values().toSeq
-        new EnumTypeDefinition(et.name, et.description, eVals: _*)
+        new EnumTypeDefinition(et.name, et.description, et.version, eVals: _*)
     }
 
     private def convertStructTypeToStructDef(st: StructType): StructTypeDefinition = {
 
         val aDefs: Iterable[AttributeDefinition] =
             st.fieldMapping.fields.values().map(convertAttributeInfoToAttributeDef(_))
-        new StructTypeDefinition(st.name, st.description, aDefs.toArray)
+        new StructTypeDefinition(st.name, st.description, st.version, aDefs.toArray)
     }
 
     private def convertTraitTypeToHierarchicalTypeDefinition(tt: TraitType): HierarchicalTypeDefinition[TraitType] = {
 
         val aDefs: Iterable[AttributeDefinition] =
             tt.immediateAttrs.map(convertAttributeInfoToAttributeDef(_))
-        new HierarchicalTypeDefinition[TraitType](classOf[TraitType], tt.name, tt.description, tt.superTypes, aDefs.toArray)
+        new HierarchicalTypeDefinition[TraitType](classOf[TraitType], tt.name, tt.description, tt.version, tt.superTypes, aDefs.toArray)
     }
 
     private def convertClassTypeToHierarchicalTypeDefinition(tt: ClassType): HierarchicalTypeDefinition[ClassType] = {
 
         val aDefs: Iterable[AttributeDefinition] =
             tt.immediateAttrs.map(convertAttributeInfoToAttributeDef(_))
-        new HierarchicalTypeDefinition[ClassType](classOf[ClassType], tt.name, tt.description, tt.superTypes, aDefs.toArray)
+        new HierarchicalTypeDefinition[ClassType](classOf[ClassType], tt.name, tt.description, tt.version, tt.superTypes, aDefs.toArray)
     }
 
     def convertToTypesDef(ts: TypeSystem, export: IDataType[_] => Boolean): TypesDef = {
@@ -229,26 +230,36 @@ trait TypeHelpers {
     HierarchicalTypeDefinition[TraitType] = {
         createTraitTypeDef(name, None, superTypes, attrDefs:_*)
     }
-    
+
     def createTraitTypeDef(name: String, description: Option[String], superTypes: Seq[String], attrDefs: AttributeDefinition*):
     HierarchicalTypeDefinition[TraitType] = {
-        val sts = ImmutableSet.copyOf(superTypes.toArray)
-        return new HierarchicalTypeDefinition[TraitType](classOf[TraitType], name, description.getOrElse(null),
-            sts, attrDefs.toArray)
+        createTraitTypeDef(name, None, AtlasConstants.DEFAULT_TYPE_VERSION, superTypes, attrDefs:_*)
+    }
+
+    def createTraitTypeDef(name: String, description: Option[String], version: String,superTypes: Seq[String], attrDefs: AttributeDefinition*):
+    HierarchicalTypeDefinition[TraitType] = {
+      val sts = ImmutableSet.copyOf(superTypes.toArray)
+      return new HierarchicalTypeDefinition[TraitType](classOf[TraitType], name, description.getOrElse(null),
+        sts, attrDefs.toArray)
     }
 
     def createClassTypeDef(name: String, superTypes: Seq[String], attrDefs: AttributeDefinition*):
     HierarchicalTypeDefinition[ClassType] = {
          createClassTypeDef( name, None, superTypes, attrDefs:_*)
     }
-    
+
     def createClassTypeDef(name: String, description: Option[String], superTypes: Seq[String], attrDefs: AttributeDefinition*):
     HierarchicalTypeDefinition[ClassType] = {
-        val sts = ImmutableSet.copyOf(superTypes.toArray)
-        return new HierarchicalTypeDefinition[ClassType](classOf[ClassType], name, description.getOrElse(null),
-            sts, attrDefs.toArray)
+      createClassTypeDef( name, None, None, superTypes, attrDefs:_*)
     }
 
+    def createClassTypeDef(name: String, description: Option[String], version: Option[String], superTypes: Seq[String], attrDefs: AttributeDefinition*):
+    HierarchicalTypeDefinition[ClassType] = {
+      val sts = ImmutableSet.copyOf(superTypes.toArray)
+      return new HierarchicalTypeDefinition[ClassType](classOf[ClassType], name, description.getOrElse(null), AtlasConstants.DEFAULT_TYPE_VERSION, sts, attrDefs.toArray)
+    }
+
+
     @throws(classOf[AtlasException])
     def defineClassType(ts: TypeSystem, classDef: HierarchicalTypeDefinition[ClassType]): ClassType = {
         ts.defineTypes(ImmutableList.of[EnumTypeDefinition], ImmutableList.of[StructTypeDefinition],


Mime
View raw message