Skip to content

A
atlas
Commit 33d60746 by Suma Shivaprasad
Options

ATLAS-1257 Map Entity REST APIs to ATLAS v1 backend (sumasai)

parent 758b3d4d
Showing with 1956 additions and 58 deletions
distro/src/bin/atlas_stop.py
......@@ -64,9 +64,9 @@ def main():
if mc.is_hbase_local(confdir):
mc.run_hbase_action(mc.hbaseBinDir(atlas_home), "stop", None, None, True)
if mc.exist_pid(pid):
#after 30 seconds kill it
time.sleep(30)
if mc.exist_pid(pid):
try:
sys.stderr.write("did not stop gracefully after 30 seconds seconds: killing with SIGKILL\n")
os.kill(pid, SIGKILL)
......
intg/src/main/java/org/apache/atlas/AtlasErrorCode.java
......@@ -49,6 +49,7 @@ public enum AtlasErrorCode {
INSTANCE_GUID_NOT_FOUND(404, "ATLAS4045E", "Given instance guid {0} is invalid"),
INSTANCE_LINEAGE_INVALID_PARAMS(404, "ATLAS4046E", "Invalid lineage query parameters passed {0}: {1}"),
INSTANCE_LINEAGE_QUERY_FAILED(404, "ATLAS4047E", "Instance lineage query failed {0}"),
INSTANCE_ALREADY_EXISTS(405, "ATLAS4051E", "Given entity with guid/name {0} already exists"),
TYPE_ALREADY_EXISTS(409, "ATLAS4091E", "Given type {0} already exists"),
TYPE_HAS_REFERENCES(409, "ATLAS4092E", "Given type {0} has references"),
......@@ -57,9 +58,12 @@ public enum AtlasErrorCode {
INTERNAL_ERROR(500, "ATLAS5001E", "Internal server error {0}"),
INDEX_CREATION_FAILED(500, "ATLAS5002E", "Index creation failed for {0}"),
INDEX_ROLLBACK_FAILED(500, "ATLAS5003E", "Index rollback failed for {0}"),
PATCH_NOT_APPLICABLE_FOR_TYPE(500, "ATLAS5004E", "{0} - invalid patch for type {1}"),
PATCH_FOR_UNKNOWN_TYPE(500, "ATLAS5005E", "{0} - patch references unknown type {1}")
;
PATCH_FOR_UNKNOWN_TYPE(500, "ATLAS5005E", "{0} - patch references unknown type {1}"),
ATTRIBUTE_UNIQUE_INVALID(400, "ATLAS40015E", "Type {0} with unique attribute {1} does not exist"),
TYPE_NAME_INVALID(400, "ATLAS40016E", "Type {0} with name {1} does not exist"),
TYPE_CATEGORY_INVALID(400, "ATLAS40017E", "Type Category {0} does not match {1} or is invalid");
private String errorCode;
private String errorMessage;
......
intg/src/main/java/org/apache/atlas/exception/AtlasBaseException.java
......@@ -20,6 +20,7 @@ package org.apache.atlas.exception;
import org.apache.atlas.AtlasErrorCode;
import javax.ws.rs.core.Response;
import java.util.List;
/**
* Base Exception class for Atlas API.
......@@ -33,6 +34,11 @@ public class AtlasBaseException extends Exception {
this.atlasErrorCode = errorCode;
}
public AtlasBaseException(final AtlasErrorCode errorCode, final List<String> params) {
super(errorCode.getFormattedErrorMessage(params.toArray(new String[params.size()])));
this.atlasErrorCode = errorCode;
}
public AtlasBaseException() {
this(AtlasErrorCode.INTERNAL_ERROR);
}
......@@ -69,6 +75,11 @@ public class AtlasBaseException extends Exception {
this.atlasErrorCode = AtlasErrorCode.INTERNAL_ERROR;
}
public AtlasBaseException(final AtlasErrorCode errorCode, Throwable cause, final List<String> params) {
super(errorCode.getFormattedErrorMessage(params.toArray(new String[params.size()])), cause);
this.atlasErrorCode = errorCode;
}
public AtlasErrorCode getAtlasErrorCode() {
return atlasErrorCode;
}
......
intg/src/main/java/org/apache/atlas/model/instance/AtlasEntity.java
......@@ -21,6 +21,8 @@ import java.io.Serializable;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicLong;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
......@@ -33,6 +35,8 @@ import org.apache.atlas.model.typedef.AtlasEntityDef;
import org.codehaus.jackson.annotate.JsonAutoDetect;
import static org.codehaus.jackson.annotate.JsonAutoDetect.Visibility.PUBLIC_ONLY;
import static org.codehaus.jackson.annotate.JsonAutoDetect.Visibility.NONE;
import org.codehaus.jackson.annotate.JsonIgnore;
import org.codehaus.jackson.annotate.JsonIgnoreProperties;
import org.codehaus.jackson.map.annotate.JsonSerialize;
......@@ -61,6 +65,9 @@ public class AtlasEntity extends AtlasStruct implements Serializable {
private Date updateTime = null;
private Long version = null;
@JsonIgnore
private static AtomicLong s_nextId = new AtomicLong(System.nanoTime());
public AtlasEntity() {
this(null, null);
}
......@@ -76,7 +83,7 @@ public class AtlasEntity extends AtlasStruct implements Serializable {
public AtlasEntity(String typeName, Map<String, Object> attributes) {
super(typeName, attributes);
setGuid(null);
setGuid(nextInternalId());
setStatus(null);
setCreatedBy(null);
setUpdatedBy(null);
......@@ -239,4 +246,39 @@ public class AtlasEntity extends AtlasStruct implements Serializable {
super(list, startIndex, pageSize, totalCount, sortType, sortBy);
}
}
@JsonIgnore
public boolean validate(String id) {
try {
long l = Long.parseLong(id);
return l < 0;
} catch (NumberFormatException ne) {
return false;
}
}
@JsonIgnore
public boolean isUnassigned() {
return guid != null && guid.length() > 0 && guid.charAt(0) == '-';
}
@JsonIgnore
public boolean isAssigned() {
return isAssigned(guid);
}
@JsonIgnore
public static boolean isAssigned(String guid) {
try {
UUID.fromString(guid);
} catch (IllegalArgumentException e) {
return false;
}
return true;
}
private String nextInternalId() {
return "-" + Long.toString(s_nextId.getAndIncrement());
}
}
intg/src/main/java/org/apache/atlas/model/instance/AtlasObjectId.java
......@@ -31,6 +31,7 @@ import org.apache.atlas.model.SearchFilter.SortType;
import org.codehaus.jackson.annotate.JsonAutoDetect;
import static org.codehaus.jackson.annotate.JsonAutoDetect.Visibility.PUBLIC_ONLY;
import static org.codehaus.jackson.annotate.JsonAutoDetect.Visibility.NONE;
import org.codehaus.jackson.annotate.JsonIgnoreProperties;
import org.codehaus.jackson.map.annotate.JsonSerialize;
......@@ -140,7 +141,6 @@ public class AtlasObjectId implements Serializable {
return toString(new StringBuilder()).toString();
}
/**
* REST serialization friendly list.
*/
......
intg/src/main/java/org/apache/atlas/model/instance/EntityMutationResponse.java
......@@ -61,7 +61,7 @@ public class EntityMutationResponse {
this.entitiesMutated = opVsEntityMap;
}
List<AtlasEntityHeader> getEntitiesByOperation(EntityMutations.EntityOperation op) {
public List<AtlasEntityHeader> getEntitiesByOperation(EntityMutations.EntityOperation op) {
if ( entitiesMutated != null) {
return entitiesMutated.get(op);
}
......
intg/src/main/java/org/apache/atlas/type/AtlasTypeUtil.java
......@@ -32,13 +32,14 @@ import org.apache.atlas.model.typedef.AtlasTypesDef;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Arrays;
import static org.apache.atlas.model.typedef.AtlasBaseTypeDef.ATLAS_TYPE_ARRAY_PREFIX;
import static org.apache.atlas.model.typedef.AtlasBaseTypeDef.ATLAS_TYPE_ARRAY_SUFFIX;
......@@ -112,21 +113,21 @@ public class AtlasTypeUtil {
public static AtlasAttributeDef createOptionalAttrDef(String name, AtlasType dataType) {
return new AtlasAttributeDef(name, dataType.getTypeName(), true,
Cardinality.SINGLE, 0, 1,
true, false,
false, false,
Collections.<AtlasStructDef.AtlasConstraintDef>emptyList());
}
public static AtlasAttributeDef createOptionalAttrDef(String name, String dataType) {
return new AtlasAttributeDef(name, dataType, true,
Cardinality.SINGLE, 0, 1,
true, false,
false, false,
Collections.<AtlasStructDef.AtlasConstraintDef>emptyList());
}
public static AtlasAttributeDef createRequiredAttrDef(String name, String dataType) {
return new AtlasAttributeDef(name, dataType, false,
Cardinality.SINGLE, 1, 1,
false, false,
false, true,
Collections.<AtlasStructDef.AtlasConstraintDef>emptyList());
}
......@@ -147,7 +148,7 @@ public class AtlasTypeUtil {
public static AtlasAttributeDef createRequiredAttrDef(String name, AtlasType dataType) {
return new AtlasAttributeDef(name, dataType.getTypeName(), false,
Cardinality.SINGLE, 1, 1,
false, false,
false, true,
Collections.<AtlasStructDef.AtlasConstraintDef>emptyList());
}
......
intg/src/test/java/org/apache/atlas/TestUtilsV2.java
......@@ -22,7 +22,7 @@ import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import org.apache.atlas.model.instance.AtlasEntity;
import org.apache.atlas.model.instance.AtlasObjectId;
import org.apache.atlas.model.instance.AtlasStruct;
import org.apache.atlas.model.typedef.AtlasClassificationDef;
import org.apache.atlas.model.typedef.AtlasEntityDef;
import org.apache.atlas.model.typedef.AtlasEnumDef;
......@@ -35,6 +35,8 @@ import org.apache.commons.lang.RandomStringUtils;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Struct;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
......@@ -432,7 +434,8 @@ public final class TestUtilsV2 {
AtlasTypeUtil.createClassTypeDef(COLUMN_TYPE, COLUMN_TYPE + "_description",
ImmutableSet.<String>of(),
AtlasTypeUtil.createUniqueRequiredAttrDef("name", "string"),
AtlasTypeUtil.createRequiredAttrDef("type", "string"));
AtlasTypeUtil.createRequiredAttrDef("type", "string")
);
AtlasStructDef partitionDefinition = new AtlasStructDef("partition_struct_type", "partition_struct_type" + _description, "1.0",
Arrays.asList(AtlasTypeUtil.createRequiredAttrDef("name", "string")));
......@@ -614,8 +617,18 @@ public final class TestUtilsV2 {
entity.setAttribute("description", "random table");
entity.setAttribute("type", "type");
entity.setAttribute("tableType", "MANAGED");
entity.setAttribute("database", new AtlasObjectId(DATABASE_TYPE, dbId));
entity.setAttribute("database", dbId);
entity.setAttribute("created", new Date());
Map<String, Object> partAttributes = new HashMap<String, Object>() {{
put("name", "part0");
}};
final AtlasStruct partitionStruct = new AtlasStruct("partition_struct_type", partAttributes);
entity.setAttribute("partitions", new ArrayList<AtlasStruct>() {{ add(partitionStruct); }});
entity.setAttribute("parametersMap", new java.util.HashMap<String, String>() {{
put("key1", "value1");
}});
return entity;
}
......
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-1257 Map Entity REST APIs to ATLAS v1 backend (sumasai)
ATLAS-1279 Remove QueryPlan attribute from Hive Process entity (svimal2106)
ATLAS-1234 Lineage REST API - v2 (sarath.kum4r@gmail.com via mneethiraj)
ATLAS-1276 fix for webapp test failures (ayubkhan via mneethiraj)
......
repository/src/main/java/org/apache/atlas/services/DefaultMetadataService.java
......@@ -292,14 +292,29 @@ public class DefaultMetadataService implements MetadataService, ActiveStateChang
* @return entity definition as JSON
*/
@Override
public String getEntityDefinition(String guid) throws AtlasException {
public String getEntityDefinitionJson(String guid) throws AtlasException {
guid = ParamChecker.notEmpty(guid, "entity id");
final ITypedReferenceableInstance instance = repository.getEntityDefinition(guid);
return InstanceSerialization.toJson(instance, true);
}
private ITypedReferenceableInstance getEntityDefinitionReference(String entityType, String attribute, String value)
/**
* Return the definition for the given guid.
*
* @param guid guid
* @return entity definition as JSON
*/
@Override
public ITypedReferenceableInstance getEntityDefinition(String guid) throws AtlasException {
guid = ParamChecker.notEmpty(guid, "entity id");
final ITypedReferenceableInstance instance = repository.getEntityDefinition(guid);
return instance;
}
@Override
public ITypedReferenceableInstance getEntityDefinitionReference(String entityType, String attribute, String value)
throws AtlasException {
validateTypeExists(entityType);
validateUniqueAttribute(entityType, attribute);
......@@ -356,6 +371,19 @@ public class DefaultMetadataService implements MetadataService, ActiveStateChang
return entityResult;
}
/**
* Updates an entity, instance of the type based on the guid set.
*
* @param entityInstanceDefinitions
* @return guids - json array of guids
*/
@Override
public AtlasClient.EntityResult updateEntities(ITypedReferenceableInstance[] entityInstanceDefinitions) throws AtlasException {
AtlasClient.EntityResult entityResult = repository.updateEntities(entityInstanceDefinitions);
onEntitiesAddedUpdated(entityResult);
return entityResult;
}
private void onEntitiesAddedUpdated(AtlasClient.EntityResult entityResult) throws AtlasException {
onEntitiesAdded(entityResult.getCreatedEntities());
onEntitiesUpdated(entityResult.getUpdateEntities());
......
repository/src/test/java/org/apache/atlas/service/DefaultMetadataServiceTest.java
......@@ -221,7 +221,7 @@ public class DefaultMetadataServiceTest {
//Verify that get entity definition returns actual values with reserved characters
Referenceable instance =
InstanceSerialization.fromJsonReferenceable(metadataService.getEntityDefinition(id), true);
InstanceSerialization.fromJsonReferenceable(metadataService.getEntityDefinitionJson(id), true);
assertReferenceableEquals(instance, entity);
//Verify that search with reserved characters works - for string attribute
......@@ -693,7 +693,7 @@ public class DefaultMetadataServiceTest {
serdeInstance.setNull("description");
updateInstance(table);
tableDefinitionJson =
metadataService.getEntityDefinition(tableId._getId());
metadataService.getEntityDefinitionJson(tableId._getId());
tableDefinition = InstanceSerialization.fromJsonReferenceable(tableDefinitionJson, true);
Assert.assertNull(((Struct) tableDefinition.get("serde1")).get("description"));
}
......@@ -733,7 +733,7 @@ public class DefaultMetadataServiceTest {
metadataService.updateEntityAttributeByGuid(tableId._getId(), "database", dbId);
String tableDefinitionJson =
metadataService.getEntityDefinition(tableId._getId());
metadataService.getEntityDefinitionJson(tableId._getId());
Referenceable tableDefinition = InstanceSerialization.fromJsonReferenceable(tableDefinitionJson, true);
assertEquals(dbId, (((Id) tableDefinition.get("database"))._getId()));
......
server-api/src/main/java/org/apache/atlas/services/MetadataService.java
......@@ -101,13 +101,27 @@ public interface MetadataService {
*/
List<String> createEntities(ITypedReferenceableInstance[] typedInstances) throws AtlasException;
/**
* Return the definition for the given guid.
*
* @param guid guid
* @return entity definition as JSON
*/
String getEntityDefinition(String guid) throws AtlasException;
String getEntityDefinitionJson(String guid) throws AtlasException;
ITypedReferenceableInstance getEntityDefinition(String guid) throws AtlasException;
/**
* Return the definition given type and attribute. The attribute has to be unique attribute for the type
* @param entityType - type name
* @param attribute - attribute name
* @param value - attribute value
* @return
* @throws AtlasException
*/
ITypedReferenceableInstance getEntityDefinitionReference(String entityType, String attribute, String value) throws AtlasException;
/**
* Return the definition given type and attribute. The attribute has to be unique attribute for the type
......@@ -155,6 +169,15 @@ public interface MetadataService {
*/
AtlasClient.EntityResult updateEntities(String entityJson) throws AtlasException;
/**
* Batch API - Adds/Updates the given entity id(guid).
*
* @param entityJson entity json
* @return json array of guids of entities created/updated
*/
AtlasClient.EntityResult updateEntities(ITypedReferenceableInstance[] iTypedReferenceableInstances) throws AtlasException;
// Trait management functions
/**
......
webapp/src/main/java/org/apache/atlas/web/adapters/AtlasArrayFormatConverter.java 0 → 100644
/**
* 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.web.adapters;
import org.apache.atlas.exception.AtlasBaseException;
import org.apache.atlas.model.TypeCategory;
import org.apache.atlas.type.AtlasArrayType;
import org.apache.atlas.type.AtlasType;
import org.apache.atlas.type.AtlasTypeRegistry;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static org.apache.atlas.web.adapters.AtlasFormatConverters.VERSION_V1;
import static org.apache.atlas.web.adapters.AtlasFormatConverters.VERSION_V2;
public class AtlasArrayFormatConverter implements AtlasFormatAdapter {
protected AtlasFormatConverters registry;
@Inject
public void init(AtlasFormatConverters registry) throws AtlasBaseException {
this.registry = registry;
registry.registerConverter(this, AtlasFormatConverters.VERSION_V1, AtlasFormatConverters.VERSION_V2);
registry.registerConverter(this, AtlasFormatConverters.VERSION_V2, AtlasFormatConverters.VERSION_V1);
}
@Override
public TypeCategory getTypeCategory() {
return TypeCategory.ARRAY;
}
@Override
public Object convert(String sourceVersion, String targetVersion, AtlasType type, final Object source) throws AtlasBaseException {
Collection newCollection = null;
if ( source != null ) {
if (AtlasFormatConverters.isArrayListType(source.getClass())) {
newCollection = new ArrayList();
} else if (AtlasFormatConverters.isSetType(source.getClass())) {
newCollection = new LinkedHashSet();
}
AtlasArrayType arrType = (AtlasArrayType) type;
AtlasType elemType = arrType.getElementType();
Collection originalList = (Collection) source;
for (Object elem : originalList) {
AtlasFormatAdapter elemConverter = registry.getConverter(sourceVersion, targetVersion, elemType.getTypeCategory());
Object convertedVal = elemConverter.convert(sourceVersion, targetVersion, elemType, elem);
newCollection.add(convertedVal);
}
}
return newCollection;
}
}
webapp/src/main/java/org/apache/atlas/web/adapters/AtlasEnumFormatConverter.java 0 → 100644
/**
* 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.web.adapters;
import org.apache.atlas.exception.AtlasBaseException;
import org.apache.atlas.model.TypeCategory;
import org.apache.atlas.type.AtlasType;
import org.apache.atlas.type.AtlasTypeRegistry;
import javax.inject.Inject;
public class AtlasEnumFormatConverter extends AtlasPrimitiveFormatConverter {
@Inject
public void init(AtlasFormatConverters registry) throws AtlasBaseException {
super.init(registry);
}
@Override
public TypeCategory getTypeCategory() {
return TypeCategory.ENUM;
}
}
webapp/src/main/java/org/apache/atlas/web/adapters/AtlasFormatAdapter.java 0 → 100644
/**
* 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.web.adapters;
import org.apache.atlas.exception.AtlasBaseException;
import org.apache.atlas.model.TypeCategory;
import org.apache.atlas.type.AtlasType;
public interface AtlasFormatAdapter {
Object convert(String sourceVersion, String targetVersion, AtlasType type, Object source) throws AtlasBaseException;
TypeCategory getTypeCategory();
}
webapp/src/main/java/org/apache/atlas/web/adapters/AtlasFormatConverters.java 0 → 100644
/**
* 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.web.adapters;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import org.apache.atlas.AtlasErrorCode;
import org.apache.atlas.exception.AtlasBaseException;
import org.apache.atlas.model.TypeCategory;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
@Singleton
public class AtlasFormatConverters {
public static String VERSION_V1 = "v1";
public static String VERSION_V2 = "v2";
private Map<String, AtlasFormatAdapter> registry = new HashMap<>();
public void registerConverter(AtlasFormatAdapter adapter, String sourceVersion, String targetVersion) {
registry.put(getKey(sourceVersion, targetVersion, adapter.getTypeCategory()), adapter);
}
public AtlasFormatAdapter getConverter(String sourceVersion, String targetVersion, TypeCategory typeCategory) throws AtlasBaseException {
if (registry.containsKey(getKey(sourceVersion, targetVersion, typeCategory))) {
return registry.get(getKey(sourceVersion, targetVersion, typeCategory));
}
throw new AtlasBaseException(AtlasErrorCode.INTERNAL_ERROR, "Could not find the converter for this type " + typeCategory);
}
public static boolean isArrayListType(Class c) {
return List.class.isAssignableFrom(c);
}
public static boolean isSetType(Class c) {
return Set.class.isAssignableFrom(c);
}
public static boolean isPrimitiveType(final Class c) {
if (c != null) {
if (Number.class.isAssignableFrom(c)) {
return true;
}
if (String.class.isAssignableFrom(c)) {
return true;
}
if (Date.class.isAssignableFrom(c)) {
return true;
}
return c.isPrimitive();
}
return false;
}
public static boolean isMapType(Object o) {
if ( o != null ) {
return Map.class.isAssignableFrom(o.getClass());
}
return false;
}
String getKey(String sourceVersion, String targetVersion, TypeCategory typeCategory) {
return sourceVersion + "-to-" + targetVersion + "-" + typeCategory.name();
}
}
webapp/src/main/java/org/apache/atlas/web/adapters/AtlasFormatConvertersModule.java 0 → 100644
/**
* 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.web.adapters;
import com.google.inject.AbstractModule;
import com.google.inject.multibindings.Multibinder;
import org.apache.atlas.web.adapters.v1.ReferenceableToAtlasEntityConverter;
import org.apache.atlas.web.adapters.v1.StructToAtlasStructConverter;
import org.apache.atlas.web.adapters.v1.TraitToAtlasClassificationConverter;
import org.apache.atlas.web.adapters.v2.AtlasClassificationToTraitConverter;
import org.apache.atlas.web.adapters.v2.AtlasEntityToReferenceableConverter;
import org.apache.atlas.web.adapters.v2.AtlasStructToStructConverter;
public class AtlasFormatConvertersModule extends AbstractModule {
protected void configure() {
Multibinder<AtlasFormatAdapter> multibinder
= Multibinder.newSetBinder(binder(), AtlasFormatAdapter.class);
multibinder.addBinding().to(AtlasStructToStructConverter.class).asEagerSingleton();
multibinder.addBinding().to(AtlasEntityToReferenceableConverter.class).asEagerSingleton();
multibinder.addBinding().to(AtlasClassificationToTraitConverter.class).asEagerSingleton();
multibinder.addBinding().to(AtlasPrimitiveFormatConverter.class).asEagerSingleton();
multibinder.addBinding().to(AtlasEnumFormatConverter.class).asEagerSingleton();
multibinder.addBinding().to(AtlasMapFormatConverter.class).asEagerSingleton();
multibinder.addBinding().to(AtlasArrayFormatConverter.class).asEagerSingleton();
multibinder.addBinding().to(ReferenceableToAtlasEntityConverter.class).asEagerSingleton();
multibinder.addBinding().to(StructToAtlasStructConverter.class).asEagerSingleton();
multibinder.addBinding().to(TraitToAtlasClassificationConverter.class).asEagerSingleton();
}
}
\ No newline at end of file
webapp/src/main/java/org/apache/atlas/web/adapters/AtlasInstanceRestAdapters.java 0 → 100644
/**
* 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.web.adapters;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import org.apache.atlas.AtlasClient;
import org.apache.atlas.AtlasErrorCode;
import org.apache.atlas.AtlasException;
import org.apache.atlas.exception.AtlasBaseException;
import org.apache.atlas.model.TypeCategory;
import org.apache.atlas.model.instance.AtlasClassification;
import org.apache.atlas.model.instance.AtlasEntity;
import org.apache.atlas.model.instance.AtlasEntityHeader;
import org.apache.atlas.model.instance.AtlasEntityWithAssociations;
import org.apache.atlas.model.instance.EntityMutationResponse;
import org.apache.atlas.model.instance.EntityMutations;
import org.apache.atlas.services.MetadataService;
import org.apache.atlas.type.AtlasType;
import org.apache.atlas.type.AtlasTypeRegistry;
import org.apache.atlas.typesystem.IReferenceableInstance;
import org.apache.atlas.typesystem.IStruct;
import org.apache.atlas.typesystem.ITypedReferenceableInstance;
import org.apache.atlas.typesystem.ITypedStruct;
import org.apache.atlas.typesystem.Referenceable;
import org.apache.atlas.typesystem.Struct;
import org.apache.atlas.typesystem.exception.EntityNotFoundException;
import org.apache.atlas.typesystem.exception.TypeNotFoundException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.List;
@Singleton
public class AtlasInstanceRestAdapters {
private static final Logger LOG = LoggerFactory.getLogger(AtlasInstanceRestAdapters.class);
@Inject
private AtlasTypeRegistry typeRegistry;
@Inject
private AtlasFormatConverters instanceFormatters;
@Inject
private MetadataService metadataService;
public ITypedReferenceableInstance[] getITypedReferenceables(List<AtlasEntity> entities) throws AtlasBaseException {
ITypedReferenceableInstance[] entitiesInOldFormat = new ITypedReferenceableInstance[entities.size()];
for (int i = 0; i < entities.size(); i++) {
ITypedReferenceableInstance typedInstance = getITypedReferenceable(entities.get(i));
entitiesInOldFormat[i] = typedInstance;
}
return entitiesInOldFormat;
}
public ITypedReferenceableInstance getITypedReferenceable(AtlasEntity entity) throws AtlasBaseException {
AtlasFormatAdapter entityFormatter = instanceFormatters.getConverter(AtlasFormatConverters.VERSION_V2, AtlasFormatConverters.VERSION_V1, TypeCategory.ENTITY);
AtlasType entityType = typeRegistry.getType(entity.getTypeName());
Referenceable ref = (Referenceable) entityFormatter.convert(AtlasFormatConverters.VERSION_V2, AtlasFormatConverters.VERSION_V1, entityType, entity);
try {
return metadataService.getTypedReferenceableInstance(ref);
} catch (AtlasException e) {
LOG.error("Exception while getting a typed reference for the entity ", e);
throw toAtlasBaseException(e);
}
}
public Referenceable getReferenceable(AtlasEntity entity) throws AtlasBaseException {
AtlasFormatAdapter entityFormatter = instanceFormatters.getConverter(AtlasFormatConverters.VERSION_V2, AtlasFormatConverters.VERSION_V1, TypeCategory.ENTITY);
AtlasType entityType = typeRegistry.getType(entity.getTypeName());
return (Referenceable) entityFormatter.convert(AtlasFormatConverters.VERSION_V2, AtlasFormatConverters.VERSION_V1, entityType, entity);
}
public ITypedStruct getTrait(AtlasClassification classification) throws AtlasBaseException {
AtlasFormatAdapter formatter = instanceFormatters.getConverter(AtlasFormatConverters.VERSION_V2, AtlasFormatConverters.VERSION_V1, TypeCategory.CLASSIFICATION);
AtlasType clsType = typeRegistry.getType(classification.getTypeName());
Struct ref = (Struct) formatter.convert(AtlasFormatConverters.VERSION_V2, AtlasFormatConverters.VERSION_V1, clsType, classification);
try {
return metadataService.createTraitInstance(ref);
} catch (AtlasException e) {
LOG.error("Exception while getting a typed reference for the entity ", e);
throw toAtlasBaseException(e);
}
}
public AtlasClassification getClassification(IStruct classification) throws AtlasBaseException {
AtlasFormatAdapter formatter = instanceFormatters.getConverter(AtlasFormatConverters.VERSION_V1, AtlasFormatConverters.VERSION_V2, TypeCategory.CLASSIFICATION);
AtlasType clsType = typeRegistry.getType(classification.getTypeName());
return (AtlasClassification) formatter.convert(AtlasFormatConverters.VERSION_V1, AtlasFormatConverters.VERSION_V2, clsType, classification);
}
public AtlasEntityWithAssociations getAtlasEntity(IReferenceableInstance referenceable) throws AtlasBaseException {
AtlasFormatAdapter entityFormatter = instanceFormatters.getConverter(AtlasFormatConverters.VERSION_V1, AtlasFormatConverters.VERSION_V2, TypeCategory.ENTITY);
AtlasType entityType = typeRegistry.getType(referenceable.getTypeName());
return (AtlasEntityWithAssociations) entityFormatter.convert(AtlasFormatConverters.VERSION_V1, AtlasFormatConverters.VERSION_V2, entityType, referenceable);
}
public static EntityMutationResponse toEntityMutationResponse(AtlasClient.EntityResult result) {
EntityMutationResponse response = new EntityMutationResponse();
for (String guid : result.getCreatedEntities()) {
AtlasEntityHeader header = new AtlasEntityHeader();
header.setGuid(guid);
response.addEntity(EntityMutations.EntityOperation.CREATE_OR_UPDATE, header);
}
for (String guid : result.getUpdateEntities()) {
AtlasEntityHeader header = new AtlasEntityHeader();
header.setGuid(guid);
response.addEntity(EntityMutations.EntityOperation.CREATE_OR_UPDATE, header);
}
for (String guid : result.getDeletedEntities()) {
AtlasEntityHeader header = new AtlasEntityHeader();
header.setGuid(guid);
response.addEntity(EntityMutations.EntityOperation.DELETE, header);
}
return response;
}
public static AtlasBaseException toAtlasBaseException(AtlasException e) {
if ( e instanceof EntityNotFoundException) {
return new AtlasBaseException(AtlasErrorCode.INSTANCE_GUID_NOT_FOUND, e);
}
if ( e instanceof TypeNotFoundException) {
return new AtlasBaseException(AtlasErrorCode.TYPE_NAME_NOT_FOUND, e);
}
return new AtlasBaseException(e);
}
}
webapp/src/main/java/org/apache/atlas/web/adapters/AtlasMapFormatConverter.java 0 → 100644
/**
* 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.web.adapters;
import org.apache.atlas.exception.AtlasBaseException;
import org.apache.atlas.model.TypeCategory;
import org.apache.atlas.type.AtlasMapType;
import org.apache.atlas.type.AtlasType;
import org.apache.atlas.type.AtlasTypeRegistry;
import javax.inject.Inject;
import java.util.HashMap;
import java.util.Map;
public class AtlasMapFormatConverter implements AtlasFormatAdapter {
protected AtlasFormatConverters registry;
@Inject
public void init(AtlasFormatConverters registry) throws AtlasBaseException {
this.registry = registry;
registry.registerConverter(this, AtlasFormatConverters.VERSION_V1, AtlasFormatConverters.VERSION_V2);
registry.registerConverter(this, AtlasFormatConverters.VERSION_V2, AtlasFormatConverters.VERSION_V1);
}
@Override
public Map convert(String sourceVersion, String targetVersion, final AtlasType type, final Object source) throws AtlasBaseException {
Map newMap = new HashMap<>();
if ( source != null) {
Map origMap = (Map) source;
for (Object key : origMap.keySet()) {
AtlasMapType mapType = (AtlasMapType) type;
AtlasType keyType = mapType.getKeyType();
AtlasType valueType = mapType.getValueType();
AtlasFormatAdapter keyConverter = registry.getConverter(sourceVersion, targetVersion, keyType.getTypeCategory());
Object convertedKey = keyConverter.convert(sourceVersion, targetVersion, keyType, key);
Object val = origMap.get(key);
if (val != null) {
AtlasFormatAdapter valueConverter = registry.getConverter(sourceVersion, targetVersion, valueType.getTypeCategory());
newMap.put(convertedKey, valueConverter.convert(sourceVersion, targetVersion, valueType, val));
} else {
newMap.put(convertedKey, val);
}
}
}
return newMap;
}
@Override
public TypeCategory getTypeCategory() {
return TypeCategory.MAP;
}
}
webapp/src/main/java/org/apache/atlas/web/adapters/AtlasPrimitiveFormatConverter.java 0 → 100644
/**
* 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.web.adapters;
import org.apache.atlas.exception.AtlasBaseException;
import org.apache.atlas.model.TypeCategory;
import org.apache.atlas.type.AtlasType;
import org.apache.atlas.type.AtlasTypeRegistry;
import javax.inject.Inject;
import java.util.HashMap;
import java.util.Map;
public class AtlasPrimitiveFormatConverter implements AtlasFormatAdapter {
protected AtlasFormatConverters registry;
@Inject
public void init(AtlasFormatConverters registry) throws AtlasBaseException {
this.registry = registry;
registry.registerConverter(this, AtlasFormatConverters.VERSION_V1, AtlasFormatConverters.VERSION_V2);
registry.registerConverter(this, AtlasFormatConverters.VERSION_V2, AtlasFormatConverters.VERSION_V1);
}
@Override
public Object convert(final String sourceVersion, final String targetVersion, final AtlasType type, final Object source) throws AtlasBaseException {
return type.getNormalizedValue(source);
}
@Override
public TypeCategory getTypeCategory() {
return TypeCategory.PRIMITIVE;
}
}
webapp/src/main/java/org/apache/atlas/web/adapters/v1/ReferenceableToAtlasEntityConverter.java 0 → 100644
/**
* 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.web.adapters.v1;
import org.apache.atlas.exception.AtlasBaseException;
import org.apache.atlas.model.TypeCategory;
import org.apache.atlas.model.instance.AtlasClassification;
import org.apache.atlas.model.instance.AtlasEntity;
import org.apache.atlas.model.instance.AtlasEntityWithAssociations;
import org.apache.atlas.type.AtlasClassificationType;
import org.apache.atlas.type.AtlasEntityType;
import org.apache.atlas.type.AtlasType;
import org.apache.atlas.type.AtlasTypeRegistry;
import org.apache.atlas.typesystem.IReferenceableInstance;
import org.apache.atlas.typesystem.IStruct;
import org.apache.atlas.typesystem.persistence.Id;
import org.apache.atlas.web.adapters.AtlasFormatAdapter;
import org.apache.atlas.web.adapters.AtlasFormatConverters;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.List;
public class ReferenceableToAtlasEntityConverter implements AtlasFormatAdapter {
protected AtlasTypeRegistry typeRegistry;
protected AtlasFormatConverters registry;
@Inject
public ReferenceableToAtlasEntityConverter(AtlasTypeRegistry typeRegistry) {
this.typeRegistry = typeRegistry;
}
@Inject
public void init(AtlasFormatConverters registry) throws AtlasBaseException {
this.registry = registry;
registry.registerConverter(this, AtlasFormatConverters.VERSION_V1, AtlasFormatConverters.VERSION_V2);
}
@Override
public Object convert(final String sourceVersion, final String targetVersion, final AtlasType type, final Object source) throws AtlasBaseException {
AtlasEntityWithAssociations result = null;
if ( source != null) {
if ( isId(source)) {
Id idObj = (Id) source;
result = new AtlasEntityWithAssociations(idObj.getTypeName());
setId(idObj, result);
} else if (isEntityType(source) ) {
IReferenceableInstance entity = (IReferenceableInstance) source;
//Resolve attributes
StructToAtlasStructConverter converter = (StructToAtlasStructConverter) registry.getConverter(sourceVersion, targetVersion, TypeCategory.STRUCT);
result = new AtlasEntityWithAssociations(entity.getTypeName(), converter.convertAttributes((AtlasEntityType) type, entity));
//Id
setId(entity, result);
//Resolve traits
List<AtlasClassification> classifications = new ArrayList<>();
for (String traitName : entity.getTraits()) {
IStruct trait = entity.getTrait(traitName);
AtlasClassificationType traitType = (AtlasClassificationType) typeRegistry.getType(traitName);
AtlasClassification clsInstance = new AtlasClassification(traitType.getTypeName(), converter.convertAttributes(traitType, trait));
classifications.add(clsInstance);
}
result.setClassifications(classifications);
}
}
return result;
}
private boolean isEntityType(Object o) {
if ( o != null && o instanceof IReferenceableInstance) {
return true;
}
return false;
}
private boolean isId(Object o) {
if ( o != null && o instanceof Id) {
return true;
}
return false;
}
@Override
public TypeCategory getTypeCategory() {
return TypeCategory.ENTITY;
}
private void setId(IReferenceableInstance entity, AtlasEntity result) {
result.setGuid(entity.getId()._getId());
}
}
webapp/src/main/java/org/apache/atlas/web/adapters/v1/StructToAtlasStructConverter.java 0 → 100644
/**
* 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.web.adapters.v1;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import org.apache.atlas.AtlasException;
import org.apache.atlas.exception.AtlasBaseException;
import org.apache.atlas.model.TypeCategory;
import org.apache.atlas.model.instance.AtlasStruct;
import org.apache.atlas.model.typedef.AtlasStructDef;
import org.apache.atlas.type.AtlasClassificationType;
import org.apache.atlas.type.AtlasEntityType;
import org.apache.atlas.type.AtlasStructType;
import org.apache.atlas.type.AtlasType;
import org.apache.atlas.type.AtlasTypeRegistry;
import org.apache.atlas.typesystem.IStruct;
import org.apache.atlas.web.adapters.AtlasFormatAdapter;
import org.apache.atlas.web.adapters.AtlasFormatConverters;
import org.apache.atlas.web.adapters.AtlasInstanceRestAdapters;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
@Singleton
public class StructToAtlasStructConverter implements AtlasFormatAdapter {
protected AtlasFormatConverters registry;
@Inject
public void init(AtlasFormatConverters registry) throws AtlasBaseException {
this.registry = registry;
registry.registerConverter(this, AtlasFormatConverters.VERSION_V1, AtlasFormatConverters.VERSION_V2);
}
@Override
public Object convert(final String sourceVersion, final String targetVersion, final AtlasType type, final Object source) throws AtlasBaseException {
if (source != null) {
if (isStructType(source)) {
IStruct entity = (IStruct) source;
//Resolve attributes
StructToAtlasStructConverter converter = (StructToAtlasStructConverter) registry.getConverter(sourceVersion, targetVersion, TypeCategory.STRUCT);
return new AtlasStruct(type.getTypeName(), converter.convertAttributes((AtlasStructType) type, entity));
}
}
return null;
}
private boolean isStructType(Object o) {
if (o != null && o instanceof IStruct) {
return true;
}
return false;
}
@Override
public TypeCategory getTypeCategory() {
return TypeCategory.STRUCT;
}
public Map<String, Object> convertAttributes(AtlasStructType structType, Object entity) throws AtlasBaseException {
Collection<AtlasStructDef.AtlasAttributeDef> attributeDefs;
if (structType.getTypeCategory() == TypeCategory.STRUCT) {
attributeDefs = structType.getStructDef().getAttributeDefs();
} else if (structType.getTypeCategory() == TypeCategory.CLASSIFICATION) {
attributeDefs = ((AtlasClassificationType)structType).getAllAttributeDefs().values();
} else if (structType.getTypeCategory() == TypeCategory.ENTITY) {
attributeDefs = ((AtlasEntityType)structType).getAllAttributeDefs().values();
} else {
attributeDefs = Collections.emptyList();
}
Map<String, Object> newAttrMap = new HashMap<>();
for (AtlasStructDef.AtlasAttributeDef attrDef : attributeDefs) {
AtlasType attrType = structType.getAttributeType(attrDef.getName());
AtlasFormatAdapter attrConverter = registry.getConverter(AtlasFormatConverters.VERSION_V1, AtlasFormatConverters.VERSION_V2, attrType.getTypeCategory());
Object attrVal = null;
if ( AtlasFormatConverters.isMapType(entity)) {
attrVal = ((Map)entity).get(attrDef.getName());
} else {
try {
attrVal = ((IStruct)entity).get(attrDef.getName());
} catch (AtlasException e) {
throw AtlasInstanceRestAdapters.toAtlasBaseException(e);
}
}
final Object convertedVal = attrConverter.convert(AtlasFormatConverters.VERSION_V1, AtlasFormatConverters.VERSION_V2, attrType, attrVal);
newAttrMap.put(attrDef.getName(), convertedVal);
}
return newAttrMap;
}
}
webapp/src/main/java/org/apache/atlas/web/adapters/v1/TraitToAtlasClassificationConverter.java 0 → 100644
/**
* 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.web.adapters.v1;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import org.apache.atlas.AtlasException;
import org.apache.atlas.exception.AtlasBaseException;
import org.apache.atlas.model.TypeCategory;
import org.apache.atlas.model.instance.AtlasClassification;
import org.apache.atlas.model.instance.AtlasStruct;
import org.apache.atlas.model.typedef.AtlasStructDef;
import org.apache.atlas.type.AtlasClassificationType;
import org.apache.atlas.type.AtlasEntityType;
import org.apache.atlas.type.AtlasStructType;
import org.apache.atlas.type.AtlasType;
import org.apache.atlas.type.AtlasTypeRegistry;
import org.apache.atlas.typesystem.IStruct;
import org.apache.atlas.web.adapters.AtlasFormatAdapter;
import org.apache.atlas.web.adapters.AtlasFormatConverters;
import org.apache.atlas.web.adapters.AtlasInstanceRestAdapters;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
@Singleton
public class TraitToAtlasClassificationConverter extends StructToAtlasStructConverter {
@Inject
public void init(AtlasFormatConverters registry) throws AtlasBaseException {
super.init(registry);
}
@Override
public Object convert(final String sourceVersion, final String targetVersion, final AtlasType type, final Object source) throws AtlasBaseException {
AtlasStruct struct = (AtlasStruct) super.convert(sourceVersion, targetVersion, type, source);
if ( struct != null) {
return new AtlasClassification(struct.getTypeName(), struct.getAttributes());
}
return null;
}
@Override
public TypeCategory getTypeCategory() {
return TypeCategory.CLASSIFICATION;
}
}
webapp/src/main/java/org/apache/atlas/web/adapters/v2/AtlasClassificationToTraitConverter.java 0 → 100644
/**
* 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.web.adapters.v2;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import org.apache.atlas.exception.AtlasBaseException;
import org.apache.atlas.model.TypeCategory;
import org.apache.atlas.model.instance.AtlasClassification;
import org.apache.atlas.model.instance.AtlasStruct;
import org.apache.atlas.model.typedef.AtlasStructDef;
import org.apache.atlas.type.AtlasClassificationType;
import org.apache.atlas.type.AtlasEntityType;
import org.apache.atlas.type.AtlasStructType;
import org.apache.atlas.type.AtlasType;
import org.apache.atlas.type.AtlasTypeRegistry;
import org.apache.atlas.typesystem.Struct;
import org.apache.atlas.web.adapters.AtlasFormatAdapter;
import org.apache.atlas.web.adapters.AtlasFormatConverters;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
@Singleton
public class AtlasClassificationToTraitConverter extends AtlasStructToStructConverter {
@Inject
public void init(AtlasFormatConverters registry) throws AtlasBaseException {
super.init(registry);
}
@Override
public TypeCategory getTypeCategory() {
return TypeCategory.CLASSIFICATION;
}
}
webapp/src/main/java/org/apache/atlas/web/adapters/v2/AtlasEntityToReferenceableConverter.java 0 → 100644
/**
* 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.web.adapters.v2;
import org.apache.atlas.AtlasErrorCode;
import org.apache.atlas.exception.AtlasBaseException;
import org.apache.atlas.model.TypeCategory;
import org.apache.atlas.model.instance.AtlasEntity;
import org.apache.atlas.model.instance.AtlasObjectId;
import org.apache.atlas.type.AtlasEntityType;
import org.apache.atlas.type.AtlasType;
import org.apache.atlas.typesystem.Referenceable;
import org.apache.atlas.typesystem.persistence.Id;
import org.apache.atlas.web.adapters.AtlasFormatAdapter;
import org.apache.atlas.web.adapters.AtlasFormatConverters;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.StringUtils;
import javax.inject.Inject;
import java.util.Map;
public class AtlasEntityToReferenceableConverter implements AtlasFormatAdapter {
protected AtlasFormatConverters registry;
@Inject
public void init(AtlasFormatConverters registry) throws AtlasBaseException {
this.registry = registry;
registry.registerConverter(this, AtlasFormatConverters.VERSION_V2, AtlasFormatConverters.VERSION_V1);
}
@Override
public Object convert(final String sourceVersion, final String targetVersion, final AtlasType type, final Object source) throws AtlasBaseException {
if ( source != null) {
//JSOn unmarshalling gives us a Map instead of AtlasObjectId or AtlasEntity
if ( AtlasFormatConverters.isMapType(source)) {
//Could be an entity or an Id
Map srcMap = (Map) source;
String idStr = (String)srcMap.get(AtlasObjectId.KEY_GUID);
String typeName = type.getTypeName();
if (StringUtils.isEmpty(idStr)) {
throw new AtlasBaseException(AtlasErrorCode.INSTANCE_GUID_NOT_FOUND);
}
if (MapUtils.isEmpty((Map)srcMap.get(AtlasStructToStructConverter.ATTRIBUTES_PROPERTY_KEY))) {
//Convert to Id
Id id = new Id(idStr, 0, typeName);
return id;
} else {
final Map attrMap = (Map) srcMap.get(AtlasStructToStructConverter.ATTRIBUTES_PROPERTY_KEY);
//Resolve attributes
AtlasStructToStructConverter converter = (AtlasStructToStructConverter) registry.getConverter(AtlasFormatConverters.VERSION_V2, AtlasFormatConverters.VERSION_V1, TypeCategory.STRUCT);
return new Referenceable(idStr, typeName, converter.convertAttributes((AtlasEntityType)type, attrMap));
}
} else {
if ( isEntityType(source) ) {
AtlasEntity entity = (AtlasEntity) source;
String id = entity.getGuid();
//Resolve attributes
AtlasStructToStructConverter converter = (AtlasStructToStructConverter) registry.getConverter(AtlasFormatConverters.VERSION_V2, AtlasFormatConverters.VERSION_V1, TypeCategory.STRUCT);
return new Referenceable(id, entity.getTypeName(), converter.convertAttributes((AtlasEntityType)type, entity));
} else if (isTransientId(source)) {
return new Referenceable((String) source, type.getTypeName(), null);
}
}
}
return null;
}
private boolean isEntityType(Object o) {
if ( o != null && (o instanceof AtlasEntity)) {
return true;
}
return false;
}
private boolean isTransientId(Object o) {
if ( o != null && (o instanceof String)) {
return true;
}
return false;
}
@Override
public TypeCategory getTypeCategory() {
return TypeCategory.ENTITY;
}
}
webapp/src/main/java/org/apache/atlas/web/adapters/v2/AtlasStructToStructConverter.java 0 → 100644
/**
* 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.web.adapters.v2;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import org.apache.atlas.exception.AtlasBaseException;
import org.apache.atlas.model.TypeCategory;
import org.apache.atlas.model.instance.AtlasStruct;
import org.apache.atlas.model.typedef.AtlasStructDef;
import org.apache.atlas.type.AtlasClassificationType;
import org.apache.atlas.type.AtlasEntityType;
import org.apache.atlas.type.AtlasStructType;
import org.apache.atlas.type.AtlasType;
import org.apache.atlas.typesystem.Struct;
import org.apache.atlas.web.adapters.AtlasFormatAdapter;
import org.apache.atlas.web.adapters.AtlasFormatConverters;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
@Singleton
public class AtlasStructToStructConverter implements AtlasFormatAdapter {
protected AtlasFormatConverters registry;
public static final String ATTRIBUTES_PROPERTY_KEY = "attributes";
@Inject
public void init(AtlasFormatConverters registry) throws AtlasBaseException {
this.registry = registry;
registry.registerConverter(this, AtlasFormatConverters.VERSION_V2, AtlasFormatConverters.VERSION_V1);
}
@Override
public Object convert(final String sourceVersion, final String targetVersion, final AtlasType type, final Object source) throws AtlasBaseException {
if (source != null) {
//Json unmarshalling gives us a Map instead of AtlasObjectId or AtlasEntity
if (AtlasFormatConverters.isMapType(source)) {
//Could be an entity or an Id
Map srcMap = (Map) source;
final Map attrMap = (Map) srcMap.get(ATTRIBUTES_PROPERTY_KEY);
if ( attrMap != null) {
//Resolve attributes
AtlasStructToStructConverter converter = (AtlasStructToStructConverter) registry.getConverter(AtlasFormatConverters.VERSION_V2, AtlasFormatConverters.VERSION_V1, TypeCategory.STRUCT);
return new Struct(type.getTypeName(), converter.convertAttributes((AtlasStructType)type, attrMap));
}
} else if (isStructType(source)) {
AtlasStruct entity = (AtlasStruct) source;
//Resolve attributes
AtlasStructToStructConverter converter = (AtlasStructToStructConverter) registry.getConverter(AtlasFormatConverters.VERSION_V2, AtlasFormatConverters.VERSION_V1, TypeCategory.STRUCT);
return new Struct(type.getTypeName(), converter.convertAttributes((AtlasStructType) type, entity));
}
}
return null;
}
private boolean isStructType(Object o) {
if (o != null && o instanceof AtlasStruct) {
return true;
}
return false;
}
@Override
public TypeCategory getTypeCategory() {
return TypeCategory.STRUCT;
}
public Map<String, Object> convertAttributes(AtlasStructType structType, Object entity) throws AtlasBaseException {
Collection<AtlasStructDef.AtlasAttributeDef> attributeDefs;
if (structType.getTypeCategory() == TypeCategory.STRUCT) {
attributeDefs = structType.getStructDef().getAttributeDefs();
} else if (structType.getTypeCategory() == TypeCategory.CLASSIFICATION) {
attributeDefs = ((AtlasClassificationType)structType).getAllAttributeDefs().values();
} else if (structType.getTypeCategory() == TypeCategory.ENTITY) {
attributeDefs = ((AtlasEntityType)structType).getAllAttributeDefs().values();
} else {
attributeDefs = Collections.emptyList();
}
Map<String, Object> newAttrMap = new HashMap<>();
for (AtlasStructDef.AtlasAttributeDef attrDef : attributeDefs) {
AtlasType attrType = structType.getAttributeType(attrDef.getName());
AtlasFormatAdapter attrConverter = registry.getConverter(AtlasFormatConverters.VERSION_V2, AtlasFormatConverters.VERSION_V1, attrType.getTypeCategory());
Object attrVal = null;
if ( AtlasFormatConverters.isMapType(entity)) {
attrVal = ((Map)entity).get(attrDef.getName());
} else {
attrVal = ((AtlasStruct)entity).getAttribute(attrDef.getName());
}
final Object convertedVal = attrConverter.convert(AtlasFormatConverters.VERSION_V2, AtlasFormatConverters.VERSION_V1, attrType, attrVal);
newAttrMap.put(attrDef.getName(), convertedVal);
}
return newAttrMap;
}
}
webapp/src/main/java/org/apache/atlas/web/listeners/GuiceServletConfig.java
......@@ -33,11 +33,11 @@ import org.apache.atlas.notification.NotificationModule;
import org.apache.atlas.repository.graph.AtlasGraphProvider;
import org.apache.atlas.repository.graphdb.AtlasGraph;
import org.apache.atlas.service.Services;
import org.apache.atlas.web.adapters.AtlasFormatConvertersModule;
import org.apache.atlas.web.filters.ActiveServerFilter;
import org.apache.atlas.web.filters.AuditFilter;
import org.apache.atlas.web.service.ActiveInstanceElectorModule;
import org.apache.atlas.web.service.ServiceModule;
import org.apache.commons.collections.iterators.EnumerationIterator;
import org.apache.commons.configuration.Configuration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
......@@ -74,7 +74,7 @@ public class GuiceServletConfig extends GuiceServletContextListener {
LoginProcessor loginProcessor = new LoginProcessor();
loginProcessor.login();
injector = Guice.createInjector(Stage.PRODUCTION, getRepositoryModule(), new ActiveInstanceElectorModule(),
injector = Guice.createInjector(Stage.PRODUCTION, getRepositoryModule(), new AtlasFormatConvertersModule(), new ActiveInstanceElectorModule(),
new NotificationModule(), new ServiceModule(), new JerseyServletModule() {
private Configuration appConfiguration = null;
......
webapp/src/main/java/org/apache/atlas/web/resources/EntityResource.java
......@@ -179,7 +179,7 @@ public class EntityResource {
response.put(AtlasClient.ENTITIES, new JSONObject(entityResult.toString()).get(AtlasClient.ENTITIES));
String sampleEntityId = getSample(entityResult);
if (sampleEntityId != null) {
String entityDefinition = metadataService.getEntityDefinition(sampleEntityId);
String entityDefinition = metadataService.getEntityDefinitionJson(sampleEntityId);
response.put(AtlasClient.DEFINITION, new JSONObject(entityDefinition));
}
return response;
......@@ -470,7 +470,7 @@ public class EntityResource {
LOG.debug("Fetching entity definition for guid={} ", guid);
guid = ParamChecker.notEmpty(guid, "guid cannot be null");
final String entityDefinition = metadataService.getEntityDefinition(guid);
final String entityDefinition = metadataService.getEntityDefinitionJson(guid);
JSONObject response = new JSONObject();
response.put(AtlasClient.REQUEST_ID, Servlets.getRequestId());
......@@ -653,7 +653,7 @@ public class EntityResource {
perf = AtlasPerfTracer.getPerfTracer(PERF_LOG, "EntityResource.getTraitDefinitionsForEntity(" + guid + ")");
}
LOG.debug("Fetching all trait definitions for entity={}", guid);
final String entityDefinition = metadataService.getEntityDefinition(guid);
final String entityDefinition = metadataService.getEntityDefinitionJson(guid);
Referenceable entity = InstanceSerialization.fromJsonReferenceable(entityDefinition, true);
JSONArray traits = new JSONArray();
......
webapp/src/main/java/org/apache/atlas/web/rest/EntitiesREST.java
......@@ -18,19 +18,29 @@
package org.apache.atlas.web.rest;
import com.google.inject.Inject;
import org.apache.atlas.AtlasClient;
import org.apache.atlas.AtlasErrorCode;
import org.apache.atlas.AtlasException;
import org.apache.atlas.exception.AtlasBaseException;
import org.apache.atlas.model.SearchFilter;
import org.apache.atlas.model.instance.AtlasClassification;
import org.apache.atlas.model.instance.AtlasEntity;
import org.apache.atlas.model.instance.AtlasEntityHeader;
import org.apache.atlas.model.instance.AtlasEntityWithAssociations;
import org.apache.atlas.model.instance.EntityMutationResponse;
import org.apache.atlas.repository.store.graph.AtlasEntityStore;
import org.apache.atlas.services.MetadataService;
import org.apache.atlas.type.AtlasTypeRegistry;
import org.apache.atlas.typesystem.types.TypeSystem;
import org.apache.atlas.typesystem.ITypedReferenceableInstance;
import org.apache.atlas.web.adapters.AtlasFormatConverters;
import org.apache.atlas.web.adapters.AtlasInstanceRestAdapters;
import org.apache.atlas.web.util.Servlets;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static org.apache.atlas.web.adapters.AtlasInstanceRestAdapters.toAtlasBaseException;
import static org.apache.atlas.web.adapters.AtlasInstanceRestAdapters.toEntityMutationResponse;
import javax.inject.Singleton;
import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.Consumes;
......@@ -42,6 +52,8 @@ import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.Context;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
......@@ -58,14 +70,16 @@ public class EntitiesREST {
@Inject
private MetadataService metadataService;
private TypeSystem typeSystem = TypeSystem.getInstance();
private AtlasTypeRegistry typeRegistry;
@Inject
AtlasInstanceRestAdapters restAdapters;
@Inject
public EntitiesREST(AtlasEntityStore entitiesStore, AtlasTypeRegistry atlasTypeRegistry) {
LOG.info("EntitiesRest Init");
this.entitiesStore = entitiesStore;
this.typeRegistry = atlasTypeRegistry;
}
/*******
......@@ -78,7 +92,17 @@ public class EntitiesREST {
@Consumes(Servlets.JSON_MEDIA_TYPE)
@Produces(Servlets.JSON_MEDIA_TYPE)
public EntityMutationResponse createOrUpdate(List<AtlasEntity> entities) throws AtlasBaseException {
return null;
EntityMutationResponse response = null;
ITypedReferenceableInstance[] entitiesInOldFormat = restAdapters.getITypedReferenceables(entities);
try {
final AtlasClient.EntityResult result = metadataService.updateEntities(entitiesInOldFormat);
response = toEntityMutationResponse(result);
} catch (AtlasException e) {
LOG.error("Exception while getting a typed reference for the entity ", e);
throw AtlasInstanceRestAdapters.toAtlasBaseException(e);
}
return response;
}
/*******
......@@ -90,15 +114,35 @@ public class EntitiesREST {
@Consumes(Servlets.JSON_MEDIA_TYPE)
@Produces(Servlets.JSON_MEDIA_TYPE)
public EntityMutationResponse update(List<AtlasEntity> entities) throws AtlasBaseException {
return null;
return createOrUpdate(entities);
}
@GET
@Path("/guids")
@Consumes(Servlets.JSON_MEDIA_TYPE)
@Produces(Servlets.JSON_MEDIA_TYPE)
public EntityMutationResponse getById(@QueryParam("guid") List<String> guids) throws AtlasBaseException {
return null;
public AtlasEntity.AtlasEntities getById(@QueryParam("guid") List<String> guids) throws AtlasBaseException {
if (CollectionUtils.isEmpty(guids)) {
throw new AtlasBaseException(AtlasErrorCode.INSTANCE_GUID_NOT_FOUND, guids);
}
AtlasEntity.AtlasEntities entities = new AtlasEntity.AtlasEntities();
List<AtlasEntity> entityList = new ArrayList<>();
for (String guid : guids) {
try {
ITypedReferenceableInstance ref = metadataService.getEntityDefinition(guid);
AtlasEntity entity = restAdapters.getAtlasEntity(ref);
entityList.add(entity);
} catch (AtlasException e) {
throw toAtlasBaseException(e);
}
}
entities.setList(entityList);
return entities;
}
/*******
......@@ -109,8 +153,17 @@ public class EntitiesREST {
@Path("/guids")
@Consumes(Servlets.JSON_MEDIA_TYPE)
@Produces(Servlets.JSON_MEDIA_TYPE)
public EntityMutationResponse deleteById(@QueryParam("guid") List<String> guids) throws AtlasBaseException {
return null;
public EntityMutationResponse deleteById(@QueryParam("guid") final List<String> guids) throws AtlasBaseException {
if (CollectionUtils.isEmpty(guids)) {
throw new AtlasBaseException(AtlasErrorCode.INSTANCE_GUID_NOT_FOUND, guids);
}
try {
AtlasClient.EntityResult result = metadataService.deleteEntities(guids);
return toEntityMutationResponse(result);
} catch (AtlasException e) {
throw toAtlasBaseException(e);
}
}
/**
......@@ -120,8 +173,9 @@ public class EntitiesREST {
*/
@GET
@Produces(Servlets.JSON_MEDIA_TYPE)
public AtlasEntity.AtlasEntities searchEntities() throws AtlasBaseException {
public AtlasEntityHeader.AtlasEntityHeaders searchEntities() throws AtlasBaseException {
//SearchFilter searchFilter
//TODO: Need to handle getEntitiesByType for older API
return null;
}
......
webapp/src/main/java/org/apache/atlas/web/rest/EntityRest.java
......@@ -17,10 +17,30 @@
*/
package org.apache.atlas.web.rest;
import com.google.inject.Inject;
import org.apache.atlas.AtlasClient;
import org.apache.atlas.AtlasErrorCode;
import org.apache.atlas.AtlasException;
import org.apache.atlas.exception.AtlasBaseException;
import org.apache.atlas.model.TypeCategory;
import org.apache.atlas.model.instance.AtlasClassification;
import org.apache.atlas.model.instance.AtlasEntity;
import org.apache.atlas.model.instance.AtlasEntityWithAssociations;
import org.apache.atlas.model.instance.EntityMutationResponse;
import org.apache.atlas.model.typedef.AtlasStructDef;
import org.apache.atlas.services.MetadataService;
import org.apache.atlas.type.AtlasEntityType;
import org.apache.atlas.type.AtlasType;
import org.apache.atlas.type.AtlasTypeRegistry;
import org.apache.atlas.typesystem.IStruct;
import org.apache.atlas.typesystem.ITypedReferenceableInstance;
import org.apache.atlas.typesystem.ITypedStruct;
import org.apache.atlas.typesystem.Referenceable;
import org.apache.atlas.web.adapters.AtlasInstanceRestAdapters;
import org.apache.atlas.web.util.Servlets;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.inject.Singleton;
import javax.ws.rs.Consumes;
......@@ -33,17 +53,30 @@ import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import java.util.ArrayList;
import java.util.List;
import static org.apache.atlas.web.adapters.AtlasInstanceRestAdapters.toAtlasBaseException;
import static org.apache.atlas.web.adapters.AtlasInstanceRestAdapters.toEntityMutationResponse;
/**
* REST for a single entity
*/
@Path("v2/entity")
@Singleton
public class EntityRest {
public class EntityREST {
private static final Logger LOG = LoggerFactory.getLogger(EntityREST.class);
@Inject
AtlasTypeRegistry typeRegistry;
@Inject
AtlasInstanceRestAdapters restAdapters;
@Inject
private MetadataService metadataService;
/**
* Create or Update an entity if it already exists
*
......@@ -53,8 +86,18 @@ public class EntityRest {
@POST
@Consumes({Servlets.JSON_MEDIA_TYPE, MediaType.APPLICATION_JSON})
@Produces(Servlets.JSON_MEDIA_TYPE)
public EntityMutationResponse createOrUpdate(AtlasEntity entity) {
return null;
public EntityMutationResponse createOrUpdate(final AtlasEntity entity) throws AtlasBaseException {
EntityMutationResponse response = null;
ITypedReferenceableInstance[] entitiesInOldFormat = restAdapters.getITypedReferenceables(new ArrayList<AtlasEntity>() {{ add(entity); }});
try {
final AtlasClient.EntityResult result = metadataService.updateEntities(entitiesInOldFormat);
response = toEntityMutationResponse(result);
} catch (AtlasException e) {
LOG.error("Exception while getting a typed reference for the entity ", e);
throw AtlasInstanceRestAdapters.toAtlasBaseException(e);
}
return response;
}
/**
......@@ -68,8 +111,8 @@ public class EntityRest {
@Path("guid/{guid}")
@Consumes({Servlets.JSON_MEDIA_TYPE, MediaType.APPLICATION_JSON})
@Produces(Servlets.JSON_MEDIA_TYPE)
public EntityMutationResponse updateByGuid(@PathParam("guid") String guid, AtlasEntity entity, @DefaultValue("false") @QueryParam("partialUpdate") boolean partialUpdate) {
return null;
public EntityMutationResponse updateByGuid(@PathParam("guid") String guid, AtlasEntity entity, @DefaultValue("false") @QueryParam("partialUpdate") boolean partialUpdate) throws AtlasBaseException {
return createOrUpdate(entity);
}
......@@ -81,11 +124,35 @@ public class EntityRest {
@GET
@Path("/guid/{guid}")
@Produces(Servlets.JSON_MEDIA_TYPE)
public AtlasEntity getByGuid(@PathParam("guid") String guid) {
return null;
public AtlasEntity getById(@PathParam("guid") String guid) throws AtlasBaseException {
try {
ITypedReferenceableInstance ref = metadataService.getEntityDefinition(guid);
return restAdapters.getAtlasEntity(ref);
} catch (AtlasException e) {
throw toAtlasBaseException(e);
}
}
/**
* Fetch the complete definition of an entity given its GUID including its associations
* like classifications, terms etc.
*
* @param guid GUID for the entity
*/
@GET
@Path("/guid/{guid}/associations")
@Produces(Servlets.JSON_MEDIA_TYPE)
public AtlasEntityWithAssociations getWithAssociationsByGuid(@PathParam("guid") String guid) throws AtlasBaseException {
try {
ITypedReferenceableInstance ref = metadataService.getEntityDefinition(guid);
return restAdapters.getAtlasEntity(ref);
} catch (AtlasException e) {
throw toAtlasBaseException(e);
}
}
/**
* Delete an entity identified by its GUID
*
......@@ -96,8 +163,16 @@ public class EntityRest {
@Path("guid/{guid}")
@Consumes({Servlets.JSON_MEDIA_TYPE, MediaType.APPLICATION_JSON})
@Produces(Servlets.JSON_MEDIA_TYPE)
public EntityMutationResponse deleteByGuid(@PathParam("guid") String guid) {
return null;
public EntityMutationResponse deleteByGuid(@PathParam("guid") final String guid) throws AtlasBaseException {
if (StringUtils.isEmpty(guid)) {
throw new AtlasBaseException(AtlasErrorCode.INSTANCE_GUID_NOT_FOUND, guid);
}
try {
AtlasClient.EntityResult result = metadataService.deleteEntities(new ArrayList<String>() {{ add(guid); }});
return toEntityMutationResponse(result);
} catch (AtlasException e) {
throw toAtlasBaseException(e);
}
}
......@@ -115,7 +190,13 @@ public class EntityRest {
public EntityMutationResponse partialUpdateByUniqueAttribute(@PathParam("typeName") String entityType,
@PathParam("attrName") String attribute,
@QueryParam("value") String value, AtlasEntity entity) throws Exception {
return null;
AtlasEntityType type = (AtlasEntityType) validateType(entityType, TypeCategory.ENTITY);
validateUniqueAttribute(type, attribute);
Referenceable ref = restAdapters.getReferenceable(entity);
AtlasClient.EntityResult result = metadataService.updateEntityByUniqueAttribute(entityType, attribute, value, ref);
return toEntityMutationResponse(result);
}
@Deprecated
......@@ -126,7 +207,12 @@ public class EntityRest {
public EntityMutationResponse deleteByUniqueAttribute(@PathParam("typeName") String entityType,
@PathParam("attrName") String attribute,
@QueryParam("value") String value) throws Exception {
return null;
AtlasEntityType type = (AtlasEntityType) validateType(entityType, TypeCategory.ENTITY);
validateUniqueAttribute(type, attribute);
final AtlasClient.EntityResult result = metadataService.deleteEntityByUniqueAttribute(entityType, attribute, value);
return toEntityMutationResponse(result);
}
/**
......@@ -140,8 +226,17 @@ public class EntityRest {
@Path("/uniqueAttribute/type/{typeName}/attribute/{attrName}")
public AtlasEntity getByUniqueAttribute(@PathParam("typeName") String entityType,
@PathParam("attrName") String attribute,
@QueryParam("value") String value) {
return null;
@QueryParam("value") String value) throws AtlasBaseException {
AtlasEntityType type = (AtlasEntityType) validateType(entityType, TypeCategory.ENTITY);
validateUniqueAttribute(type, attribute);
try {
final ITypedReferenceableInstance entityDefinitionReference = metadataService.getEntityDefinitionReference(entityType, attribute, value);
return restAdapters.getAtlasEntity(entityDefinitionReference);
} catch (AtlasException e) {
throw toAtlasBaseException(e);
}
}
......@@ -154,8 +249,21 @@ public class EntityRest {
@GET
@Path("/guid/{guid}/classification/{classificationName}")
@Produces(Servlets.JSON_MEDIA_TYPE)
public AtlasClassification.AtlasClassifications getClassification(@PathParam("guid") String guid, @PathParam("classificationName") String classificationName) {
return null;
public AtlasClassification getClassification(@PathParam("guid") String guid, @PathParam("classificationName") String classificationName) throws AtlasBaseException {
if (StringUtils.isEmpty(guid)) {
throw new AtlasBaseException(AtlasErrorCode.INSTANCE_GUID_NOT_FOUND, guid);
}
validateType(classificationName, TypeCategory.CLASSIFICATION);
try {
IStruct trait = metadataService.getTraitDefinition(guid, classificationName);
return restAdapters.getClassification(trait);
} catch (AtlasException e) {
throw toAtlasBaseException(e);
}
}
......@@ -168,8 +276,28 @@ public class EntityRest {
@GET
@Path("/guid/{guid}/classifications")
@Produces(Servlets.JSON_MEDIA_TYPE)
public AtlasClassification.AtlasClassifications getClassifications(@PathParam("guid") String guid) {
return null;
public AtlasClassification.AtlasClassifications getClassifications(@PathParam("guid") String guid) throws AtlasBaseException {
if (StringUtils.isEmpty(guid)) {
throw new AtlasBaseException(AtlasErrorCode.INSTANCE_GUID_NOT_FOUND, guid);
}
AtlasClassification.AtlasClassifications clss = new AtlasClassification.AtlasClassifications();
try {
List<AtlasClassification> clsList = new ArrayList<>();
for ( String traitName : metadataService.getTraitNames(guid) ) {
IStruct trait = metadataService.getTraitDefinition(guid, traitName);
AtlasClassification cls = restAdapters.getClassification(trait);
clsList.add(cls);
}
clss.setList(clsList);
} catch (AtlasException e) {
throw toAtlasBaseException(e);
}
return clss;
}
/**
......@@ -185,7 +313,20 @@ public class EntityRest {
@Path("/guid/{guid}/classifications")
@Consumes({Servlets.JSON_MEDIA_TYPE, MediaType.APPLICATION_JSON})
@Produces(Servlets.JSON_MEDIA_TYPE)
public void addClassifications(@PathParam("guid") final String guid, List<AtlasClassification> classifications) {
public void addClassifications(@PathParam("guid") final String guid, List<AtlasClassification> classifications) throws AtlasBaseException {
if (StringUtils.isEmpty(guid)) {
throw new AtlasBaseException(AtlasErrorCode.INSTANCE_GUID_NOT_FOUND, guid);
}
for (AtlasClassification classification: classifications) {
final ITypedStruct trait = restAdapters.getTrait(classification);
try {
metadataService.addTrait(guid, trait);
} catch (AtlasException e) {
throw toAtlasBaseException(e);
}
}
}
/**
......@@ -198,7 +339,12 @@ public class EntityRest {
@Path("/guid/{guid}/classifications")
@Consumes({Servlets.JSON_MEDIA_TYPE, MediaType.APPLICATION_JSON})
@Produces(Servlets.JSON_MEDIA_TYPE)
public void updateClassifications(@PathParam("guid") final String guid, List<AtlasClassification> classifications) {
public void updateClassifications(@PathParam("guid") final String guid, List<AtlasClassification> classifications) throws AtlasBaseException {
//Not supported in old API
if (StringUtils.isEmpty(guid)) {
throw new AtlasBaseException(AtlasErrorCode.INSTANCE_GUID_NOT_FOUND, guid);
}
}
/**
......@@ -212,6 +358,43 @@ public class EntityRest {
@Consumes({Servlets.JSON_MEDIA_TYPE, MediaType.APPLICATION_JSON})
@Produces(Servlets.JSON_MEDIA_TYPE)
public void deleteClassification(@PathParam("guid") String guid,
@PathParam("classificationName") String classificationName) {
@PathParam("classificationName") String classificationName) throws AtlasBaseException {
if (StringUtils.isEmpty(guid)) {
throw new AtlasBaseException(AtlasErrorCode.INSTANCE_GUID_NOT_FOUND, guid);
}
validateType(classificationName, TypeCategory.CLASSIFICATION);
try {
metadataService.deleteTrait(guid, classificationName);
} catch (AtlasException e) {
throw toAtlasBaseException(e);
}
}
private AtlasType validateType(String entityType, TypeCategory expectedCategory) throws AtlasBaseException {
if ( StringUtils.isEmpty(entityType) ) {
throw new AtlasBaseException(AtlasErrorCode.TYPE_NAME_INVALID, entityType);
}
AtlasType type = typeRegistry.getType(entityType);
if (type.getTypeCategory() != expectedCategory) {
throw new AtlasBaseException(AtlasErrorCode.TYPE_CATEGORY_INVALID, type.getTypeCategory().name(), expectedCategory.name());
}
return type;
}
/**
* Validate that attribute is unique attribute
* @param entityType the entity type
* @param attributeName the name of the attribute
*/
private void validateUniqueAttribute(AtlasEntityType entityType, String attributeName) throws AtlasBaseException {
AtlasStructDef.AtlasAttributeDef attribute = entityType.getAttributeDef(attributeName);
if (!attribute.getIsUnique()) {
throw new AtlasBaseException(AtlasErrorCode.ATTRIBUTE_UNIQUE_INVALID, entityType.getTypeName(), attributeName);
}
}
}
webapp/src/test/java/org/apache/atlas/web/adapters/TestEntitiesREST.java 0 → 100644
/**
* 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.web.adapters;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.atlas.AtlasClient;
import org.apache.atlas.RepositoryMetadataModule;
import org.apache.atlas.RequestContext;
import org.apache.atlas.TestUtilsV2;
import org.apache.atlas.model.instance.AtlasEntity;
import org.apache.atlas.model.instance.AtlasEntityHeader;
import org.apache.atlas.model.instance.AtlasStruct;
import org.apache.atlas.model.instance.EntityMutationResponse;
import org.apache.atlas.model.instance.EntityMutations;
import org.apache.atlas.model.typedef.AtlasTypesDef;
import org.apache.atlas.repository.graph.AtlasGraphProvider;
import org.apache.atlas.store.AtlasTypeDefStore;
import org.apache.atlas.web.rest.EntitiesREST;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.testng.Assert;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.AfterClass;
import org.testng.annotations.Guice;
import org.testng.annotations.Test;
import javax.inject.Inject;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
@Guice(modules = {AtlasFormatConvertersModule.class, RepositoryMetadataModule.class})
public class TestEntitiesREST {
private static final Logger LOG = LoggerFactory.getLogger(TestEntitiesREST.class);
@Inject
private AtlasTypeDefStore typeStore;
@Inject
private EntitiesREST entitiesREST;
private List<String> createdGuids = new ArrayList<>();
private AtlasEntity dbEntity;
private AtlasEntity tableEntity;
private List<AtlasEntity> columns;
@BeforeClass
public void setUp() throws Exception {
AtlasTypesDef typesDef = TestUtilsV2.defineHiveTypes();
typeStore.createTypesDef(typesDef);
dbEntity = TestUtilsV2.createDBEntity();
tableEntity = TestUtilsV2.createTableEntity(dbEntity.getGuid());
final AtlasEntity colEntity = TestUtilsV2.createColumnEntity();
columns = new ArrayList<AtlasEntity>() {{ add(colEntity); }};
tableEntity.setAttribute("columns", columns);
}
@AfterMethod
public void cleanup() throws Exception {
RequestContext.clear();
}
@AfterClass
public void tearDown() throws Exception {
AtlasGraphProvider.cleanup();
}
@Test
public void testCreateOrUpdateEntities() throws Exception {
List<AtlasEntity> entities = new ArrayList<AtlasEntity>();
entities.add(dbEntity);
entities.add(tableEntity);
EntityMutationResponse response = entitiesREST.createOrUpdate(entities);
List<AtlasEntityHeader> guids = response.getEntitiesByOperation(EntityMutations.EntityOperation.CREATE_OR_UPDATE);
Assert.assertNotNull(guids);
Assert.assertEquals(guids.size(), 3);
for (AtlasEntityHeader header : guids) {
createdGuids.add(header.getGuid());
}
}
@Test
public void testUpdateWithSerializedEntities() throws Exception {
//Check with serialization and deserialization of entity attributes for the case
// where attributes which are de-serialized into a map
AtlasEntity dbEntity = TestUtilsV2.createDBEntity();
AtlasEntity tableEntity = TestUtilsV2.createTableEntity(dbEntity.getGuid());
final AtlasEntity colEntity = TestUtilsV2.createColumnEntity();
List<AtlasEntity> columns = new ArrayList<AtlasEntity>() {{ add(colEntity); }};
tableEntity.setAttribute("columns", columns);
AtlasEntity newDBEntity = serDeserEntity(dbEntity);
AtlasEntity newTableEntity = serDeserEntity(tableEntity);
List<AtlasEntity> newEntities = new ArrayList<AtlasEntity>();
newEntities.add(newDBEntity);
newEntities.add(newTableEntity);
EntityMutationResponse response2 = entitiesREST.createOrUpdate(newEntities);
List<AtlasEntityHeader> newGuids = response2.getEntitiesByOperation(EntityMutations.EntityOperation.CREATE_OR_UPDATE);
Assert.assertNotNull(newGuids);
Assert.assertEquals(newGuids.size(), 3);
}
@Test(dependsOnMethods = "testCreateOrUpdateEntities")
public void testGetEntities() throws Exception {
final AtlasEntity.AtlasEntities response = entitiesREST.getById(createdGuids);
final List<AtlasEntity> entities = response.getList();
Assert.assertNotNull(entities);
Assert.assertEquals(entities.size(), 3);
verifyAttributes(entities);
}
@Test(dependsOnMethods = "testGetEntities")
public void testDeleteEntities() throws Exception {
final EntityMutationResponse response = entitiesREST.deleteById(createdGuids);
final List<AtlasEntityHeader> entities = response.getEntitiesByOperation(EntityMutations.EntityOperation.DELETE);
Assert.assertNotNull(entities);
Assert.assertEquals(entities.size(), 3);
}
private void verifyAttributes(List<AtlasEntity> retrievedEntities) throws Exception {
AtlasEntity retrievedDBEntity = null;
AtlasEntity retrievedTableEntity = null;
AtlasEntity retrievedColumnEntity = null;
for (AtlasEntity entity: retrievedEntities ) {
if ( entity.getTypeName().equals(TestUtilsV2.DATABASE_TYPE)) {
retrievedDBEntity = entity;
}
if ( entity.getTypeName().equals(TestUtilsV2.TABLE_TYPE)) {
retrievedTableEntity = entity;
}
if ( entity.getTypeName().equals(TestUtilsV2.COLUMN_TYPE)) {
retrievedColumnEntity = entity;
}
}
if ( retrievedDBEntity != null) {
LOG.info("verifying entity of type {} ", dbEntity.getTypeName());
verifyAttributes(dbEntity.getAttributes(), retrievedDBEntity.getAttributes());
}
if ( retrievedColumnEntity != null) {
LOG.info("verifying entity of type {} ", columns.get(0).getTypeName());
verifyAttributes(columns.get(0).getAttributes(), retrievedColumnEntity.getAttributes());
}
if ( retrievedTableEntity != null) {
LOG.info("verifying entity of type {} ", tableEntity.getTypeName());
//String
Assert.assertEquals(tableEntity.getAttribute(AtlasClient.NAME), retrievedTableEntity.getAttribute(AtlasClient.NAME));
//Map
Assert.assertEquals(tableEntity.getAttribute("parametersMap"), retrievedTableEntity.getAttribute("parametersMap"));
//enum
Assert.assertEquals(tableEntity.getAttribute("tableType"), retrievedTableEntity.getAttribute("tableType"));
//date
Assert.assertEquals(tableEntity.getAttribute("created"), retrievedTableEntity.getAttribute("created"));
//array of Ids
Assert.assertEquals(((List<AtlasEntity>) retrievedTableEntity.getAttribute("columns")).get(0).getGuid(), retrievedColumnEntity.getGuid());
//array of structs
Assert.assertEquals(((List<AtlasStruct>) retrievedTableEntity.getAttribute("partitions")), tableEntity.getAttribute("partitions"));
}
}
public static void verifyAttributes(Map<String, Object> sourceAttrs, Map<String, Object> targetAttributes) throws Exception {
for (String name : sourceAttrs.keySet() ) {
LOG.info("verifying attribute {} ", name);
Assert.assertEquals(targetAttributes.get(name), sourceAttrs.get(name));
}
}
AtlasEntity serDeserEntity(AtlasEntity entity) throws IOException {
//Convert from json to object and back to trigger the case where it gets translated to a map for attributes instead of AtlasEntity
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
String entityJson = mapper.writeValueAsString(entity);
//JSON from String to Object
AtlasEntity newEntity = mapper.readValue(entityJson, AtlasEntity.class);
return newEntity;
}
}
webapp/src/test/java/org/apache/atlas/web/adapters/TestEntityREST.java 0 → 100644
/**
* 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.web.adapters;
import org.apache.atlas.RepositoryMetadataModule;
import org.apache.atlas.RequestContext;
import org.apache.atlas.TestUtilsV2;
import org.apache.atlas.model.instance.AtlasClassification;
import org.apache.atlas.model.instance.AtlasEntity;
import org.apache.atlas.model.instance.AtlasEntityHeader;
import org.apache.atlas.model.instance.AtlasEntityWithAssociations;
import org.apache.atlas.model.instance.EntityMutationResponse;
import org.apache.atlas.model.instance.EntityMutations;
import org.apache.atlas.model.typedef.AtlasTypesDef;
import org.apache.atlas.repository.graph.AtlasGraphProvider;
import org.apache.atlas.store.AtlasTypeDefStore;
import org.apache.atlas.web.rest.EntityREST;
import org.testng.Assert;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.AfterClass;
import org.testng.annotations.Guice;
import org.testng.annotations.Test;
import org.testng.internal.Invoker;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
@Guice(modules = {AtlasFormatConvertersModule.class, RepositoryMetadataModule.class})
public class TestEntityREST {
@Inject
private AtlasTypeDefStore typeStore;
@Inject
private EntityREST entityREST;
private AtlasEntity dbEntity;
private String dbGuid;
private AtlasClassification testClassification;
@BeforeClass
public void setUp() throws Exception {
AtlasTypesDef typesDef = TestUtilsV2.defineHiveTypes();
typeStore.createTypesDef(typesDef);
dbEntity = TestUtilsV2.createDBEntity();
}
@AfterClass
public void tearDown() throws Exception {
AtlasGraphProvider.cleanup();
}
@AfterMethod
public void cleanup() throws Exception {
RequestContext.clear();
}
@Test
public void testCreateOrUpdateEntity() throws Exception {
final EntityMutationResponse response = entityREST.createOrUpdate(dbEntity);
Assert.assertNotNull(response);
List<AtlasEntityHeader> entitiesMutated = response.getEntitiesByOperation(EntityMutations.EntityOperation.CREATE_OR_UPDATE);
Assert.assertNotNull(entitiesMutated);
Assert.assertEquals(entitiesMutated.size(), 1);
Assert.assertNotNull(entitiesMutated.get(0));
dbGuid = entitiesMutated.get(0).getGuid();
Assert.assertEquals(entitiesMutated.size(), 1);
}
@Test(dependsOnMethods = "testCreateOrUpdateEntity")
public void testGetEntityById() throws Exception {
final AtlasEntity response = entityREST.getById(dbGuid);
Assert.assertNotNull(response);
TestEntitiesREST.verifyAttributes(response.getAttributes(), dbEntity.getAttributes());
}
@Test(dependsOnMethods = "testCreateOrUpdateEntity")
public void testAddAndGetClassification() throws Exception {
List<AtlasClassification> classifications = new ArrayList<>();
testClassification = new AtlasClassification(TestUtilsV2.CLASSIFICATION, new HashMap<String, Object>() {{ put("tag", "tagName"); }});
classifications.add(testClassification);
entityREST.addClassifications(dbGuid, classifications);
final AtlasClassification.AtlasClassifications retrievedClassifications = entityREST.getClassifications(dbGuid);
Assert.assertNotNull(retrievedClassifications);
final List<AtlasClassification> retrievedClassificationsList = retrievedClassifications.getList();
Assert.assertNotNull(retrievedClassificationsList);
Assert.assertEquals(classifications, retrievedClassificationsList);
final AtlasClassification retrievedClassification = entityREST.getClassification(dbGuid, TestUtilsV2.CLASSIFICATION);
Assert.assertNotNull(retrievedClassification);
Assert.assertEquals(retrievedClassification, testClassification);
}
@Test(dependsOnMethods = "testAddAndGetClassification")
public void testGetEntityWithAssociations() throws Exception {
AtlasEntityWithAssociations entity = entityREST.getWithAssociationsByGuid(dbGuid);
final List<AtlasClassification> retrievedClassifications = entity.getClassifications();
Assert.assertNotNull(retrievedClassifications);
Assert.assertEquals(new ArrayList<AtlasClassification>() {{ add(testClassification); }}, retrievedClassifications);
}
@Test(dependsOnMethods = "testGetEntityWithAssociations")
public void testDeleteClassification() throws Exception {
entityREST.deleteClassification(dbGuid, TestUtilsV2.CLASSIFICATION);
final AtlasClassification.AtlasClassifications retrievedClassifications = entityREST.getClassifications(dbGuid);
Assert.assertNotNull(retrievedClassifications);
Assert.assertEquals(retrievedClassifications.getList().size(), 0);
}
@Test(dependsOnMethods = "testDeleteClassification")
public void testDeleteEntityById() throws Exception {
EntityMutationResponse response = entityREST.deleteByGuid(dbGuid);
List<AtlasEntityHeader> entitiesMutated = response.getEntitiesByOperation(EntityMutations.EntityOperation.DELETE);
Assert.assertNotNull(entitiesMutated);
Assert.assertEquals(entitiesMutated.get(0).getGuid(), dbGuid);
}
@Test
public void testUpdateGetDeleteEntityByUniqueAttribute() throws Exception {
AtlasEntity dbEntity = TestUtilsV2.createDBEntity();
entityREST.createOrUpdate(dbEntity);
final String prevDBName = (String) dbEntity.getAttribute(TestUtilsV2.NAME);
final String updatedDBName = "updatedDBName";
dbEntity.setAttribute(TestUtilsV2.NAME, updatedDBName);
final EntityMutationResponse response = entityREST.partialUpdateByUniqueAttribute(TestUtilsV2.DATABASE_TYPE, TestUtilsV2.NAME, prevDBName, dbEntity);
String dbGuid = response.getEntitiesByOperation(EntityMutations.EntityOperation.CREATE_OR_UPDATE).get(0).getGuid();
Assert.assertTrue(AtlasEntity.isAssigned(dbGuid));
//Get By unique attribute
AtlasEntity entity = entityREST.getByUniqueAttribute(TestUtilsV2.DATABASE_TYPE, TestUtilsV2.NAME, updatedDBName);
Assert.assertNotNull(entity);
Assert.assertNotNull(entity.getGuid());
Assert.assertEquals(entity.getGuid(), dbGuid);
TestEntitiesREST.verifyAttributes(entity.getAttributes(), dbEntity.getAttributes());
final EntityMutationResponse deleteResponse = entityREST.deleteByUniqueAttribute(TestUtilsV2.DATABASE_TYPE, TestUtilsV2.NAME, (String) dbEntity.getAttribute(TestUtilsV2.NAME));
Assert.assertNotNull(deleteResponse.getEntitiesByOperation(EntityMutations.EntityOperation.DELETE));
Assert.assertEquals(deleteResponse.getEntitiesByOperation(EntityMutations.EntityOperation.DELETE).size(), 1);
Assert.assertEquals(deleteResponse.getEntitiesByOperation(EntityMutations.EntityOperation.DELETE).get(0).getGuid(), dbGuid);
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment