Split (2)

train · 535k rows

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.

input stringlengths 3 3.35k	context stringlengths 43 11k	output stringlengths 34 6.81k
isOperationExcludedFromAudit(String requestHttpMethod, String requestOperation, Configuration config)	AuditFilter implements Filter { boolean isOperationExcludedFromAudit(String requestHttpMethod, String requestOperation, Configuration config) { try { return AtlasRepositoryConfiguration.isExcludedFromAudit(config, requestHttpMethod, requestOperation); } catch (AtlasException e) { return false; } } @Override void init(FilterConfig filterConfig); @Override void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain); static void audit(String who, String fromAddress, String whatRequest, String fromHost, String whatURL, String whatAddrs, String whenISO9601); static void recordMetrics(); @Override void destroy(); }	@Test public void testVerifyNotExcludedOperations() { AtlasRepositoryConfiguration.resetExcludedOperations(); when(configuration.getStringArray(AtlasRepositoryConfiguration.AUDIT_EXCLUDED_OPERATIONS)).thenReturn(new String[]{"Version", "Ping"}); AuditFilter auditFilter = new AuditFilter(); assertFalse(auditFilter.isOperationExcludedFromAudit("GET", "Version", configuration)); assertFalse(auditFilter.isOperationExcludedFromAudit("GET", "Ping", configuration)); assertFalse(auditFilter.isOperationExcludedFromAudit("GET", "Types", configuration)); }
isCachedInMemory(String typeName)	StoreBackedTypeCache extends DefaultTypeCache { public boolean isCachedInMemory(String typeName) throws AtlasException { return super.has(typeName); } @Inject StoreBackedTypeCache(final ITypeStore typeStore); boolean isCachedInMemory(String typeName); @Override IDataType onTypeFault(String typeName); }	@Test public void testGetTraitType() throws Exception { ImmutableList<String> traitNames = ts.getTypeNamesByCategory(TypeCategory.TRAIT); for (String traitTypeName : traitNames) { Assert.assertFalse(typeCache.isCachedInMemory(traitTypeName)); IDataType dataType = typeCache.get(traitTypeName); Assert.assertTrue(typeCache.isCachedInMemory(traitTypeName)); Assert.assertTrue(dataType instanceof TraitType); TraitType cachedType = (TraitType)dataType; verifyHierarchicalType(cachedType, ts.getDataType(TraitType.class, traitTypeName)); } }
getIdPropertyName()	EntityTagResourceDefinition extends BaseResourceDefinition { @Override public String getIdPropertyName() { return "name"; } EntityTagResourceDefinition(); @Override String getIdPropertyName(); @Override String getTypeName(); @Override String resolveHref(Map<String, Object> properties); static final String ENTITY_GUID_PROPERTY; }	@Test public void testGetIdPropertyName() { ResourceDefinition entityTagDefinition = new EntityTagResourceDefinition(); assertEquals(entityTagDefinition.getIdPropertyName(), "name"); }
createResources(Request request)	TaxonomyResourceProvider extends BaseResourceProvider implements ResourceProvider { @Override public Collection<String> createResources(Request request) throws InvalidQueryException, ResourceNotFoundException { throw new UnsupportedOperationException( "Creating multiple Taxonomies in a request is not currently supported"); } TaxonomyResourceProvider(AtlasTypeSystem typeSystem); @Override Result getResourceById(Request request); @Override Result getResources(Request request); @Override void createResource(Request request); @Override Collection<String> createResources(Request request); @Override void deleteResourceById(Request request); @Override void updateResourceById(Request request); static final String DEFAULT_TAXONOMY_NAME; static final String DEFAULT_TAXONOMY_DESCRIPTION; static final String NAMESPACE_ATTRIBUTE_NAME; static final String TAXONOMY_TERM_TYPE; static final String TAXONOMY_NS; }	@Test(expectedExceptions = UnsupportedOperationException.class) public void testCreateResources() throws Exception { AtlasTypeSystem typeSystem = createStrictMock(AtlasTypeSystem.class); QueryFactory queryFactory = createStrictMock(QueryFactory.class); replay(typeSystem, queryFactory); Map<String, Object> requestProperties = new HashMap<>(); requestProperties.put("name", "taxonomyName"); Request userRequest = new InstanceRequest(requestProperties); TaxonomyResourceProvider provider = new TestTaxonomyResourceProvider(typeSystem); provider.setQueryFactory(queryFactory); provider.createResources(userRequest); }
createPermissionMap(List<PolicyDef> policyDefList, AtlasActionTypes permissionType, SimpleAtlasAuthorizer.AtlasAccessorTypes principalType)	PolicyUtil { public static Map<String, Map<AtlasResourceTypes, List<String>>> createPermissionMap(List<PolicyDef> policyDefList, AtlasActionTypes permissionType, SimpleAtlasAuthorizer.AtlasAccessorTypes principalType) { if (isDebugEnabled) { LOG.debug("==> PolicyUtil createPermissionMap\nCreating Permission Map for :: {} & {}", permissionType, principalType); } Map<String, Map<AtlasResourceTypes, List<String>>> userReadMap = new HashMap<>(); for (PolicyDef policyDef : policyDefList) { if (LOG.isDebugEnabled()) { LOG.debug("Processing policy def : {}", policyDef); } Map<String, List<AtlasActionTypes>> principalMap = principalType.equals(SimpleAtlasAuthorizer.AtlasAccessorTypes.USER) ? policyDef.getUsers() : policyDef .getGroups(); for (Entry<String, List<AtlasActionTypes>> e : principalMap.entrySet()) { if (!e.getValue().contains(permissionType)) { continue; } String username = e.getKey(); Map<AtlasResourceTypes, List<String>> userResourceList = userReadMap.get(username); if (userResourceList == null) { if (isDebugEnabled) { LOG.debug("Resource list not found for {}, creating it", username); } userResourceList = new HashMap<>(); } for (Entry<AtlasResourceTypes, List<String>> resourceTypeMap : policyDef.getResources().entrySet()) { AtlasResourceTypes type = resourceTypeMap.getKey(); List<String> resourceList = userResourceList.get(type); if (resourceList == null) { resourceList = new ArrayList<>(); resourceList.addAll(resourceTypeMap.getValue()); } else { resourceList.removeAll(resourceTypeMap.getValue()); resourceList.addAll(resourceTypeMap.getValue()); } userResourceList.put(type, resourceList); } userReadMap.put(username, userResourceList); if (LOG.isDebugEnabled()) { LOG.debug("userReadMap {}", userReadMap); } } } if (isDebugEnabled) { LOG.debug("Returning Map for {} :: {}", principalType, userReadMap); LOG.debug("<== PolicyUtil createPermissionMap"); } return userReadMap; } static Map<String, Map<AtlasResourceTypes, List<String>>> createPermissionMap(List<PolicyDef> policyDefList, AtlasActionTypes permissionType, SimpleAtlasAuthorizer.AtlasAccessorTypes principalType); }	@Test public void testCreatePermissionMap() { HashMap<AtlasResourceTypes, List<String>> resourceMap = new HashMap<>(); List<String> resource1List = new ArrayList<>(); resource1List.add("abc"); resourceMap.put(AtlasResourceTypes.ENTITY, resource1List); List<String> resource2List = new ArrayList<>(); resource2List.add("xyz"); resourceMap.put(AtlasResourceTypes.OPERATION, resource2List); List<String> resource3List = new ArrayList<>(); resource3List.add("PII"); resourceMap.put(AtlasResourceTypes.TYPE, resource3List); Map<String, HashMap<AtlasResourceTypes, List<String>>> permissionMap = new HashMap<>(); permissionMap.put("grp1", resourceMap); List<String> policies = new ArrayList<>(); policies.add("hivePolicy;;usr1:r,usr2:rw;;grp1:rwu,grp2:u;;entity:abc,operation:xyz,type:PII"); List<PolicyDef> policyDefList = new PolicyParser().parsePolicies(policies); Map<String, Map<AtlasResourceTypes, List<String>>> createdPermissionMap = new PolicyUtil().createPermissionMap(policyDefList, AtlasActionTypes.READ, SimpleAtlasAuthorizer.AtlasAccessorTypes.GROUP); assertEquals(permissionMap, createdPermissionMap); }
getEntity(String guid)	AtlasClient extends AtlasBaseClient { public Referenceable getEntity(String guid) throws AtlasServiceException { JSONObject jsonResponse = callAPIWithBodyAndParams(API.GET_ENTITY, null, guid); try { String entityInstanceDefinition = jsonResponse.getString(AtlasClient.DEFINITION); return InstanceSerialization.fromJsonReferenceable(entityInstanceDefinition, true); } catch (JSONException e) { throw new AtlasServiceException(API.GET_ENTITY, e); } } AtlasClient(String[] baseUrl, String cookieName, String value, String path, String domain); AtlasClient(String[] baseUrl, Cookie cookie); AtlasClient(String[] baseUrl, String[] basicAuthUserNamePassword); AtlasClient(String... baseUrls); AtlasClient(UserGroupInformation ugi, String doAsUser, String... baseUrls); private AtlasClient(UserGroupInformation ugi, String[] baseUrls); protected AtlasClient(); @VisibleForTesting AtlasClient(Configuration configuration, String[] baseUrl, String[] basicAuthUserNamePassword); @VisibleForTesting AtlasClient(Configuration configuration, String... baseUrls); @VisibleForTesting AtlasClient(WebResource service, Configuration configuration); WebResource getResource(); List<String> createType(String typeAsJson); List<String> createType(TypesDef typeDef); List<String> createTraitType(String traitName, ImmutableSet<String> superTraits, AttributeDefinition... attributeDefinitions); List<String> createTraitType(String traitName); List<String> updateType(String typeAsJson); List<String> updateType(TypesDef typeDef); List<String> listTypes(); List<String> listTypes(final DataTypes.TypeCategory category); List<String> listTypes(final DataTypes.TypeCategory category, final String superType, final String notSupertype); TypesDef getType(String typeName); List<String> createEntity(String... entitiesAsJson); List<String> createEntity(Referenceable... entities); List<String> createEntity(Collection<Referenceable> entities); EntityResult updateEntities(Referenceable... entities); EntityResult updateEntities(Collection<Referenceable> entities); EntityResult updateEntityAttribute(final String guid, final String attribute, String value); EntityResult updateEntity(String guid, Referenceable entity); void addTrait(String guid, Struct traitDefinition); void deleteTrait(String guid, String traitName); EntityResult updateEntity(final String entityType, final String uniqueAttributeName, final String uniqueAttributeValue, Referenceable entity); EntityResult deleteEntities(final String ... guids); EntityResult deleteEntity(String entityType, String uniqueAttributeName, String uniqueAttributeValue); Referenceable getEntity(String guid); static String toString(JSONArray jsonArray); Referenceable getEntity(final String entityType, final String attribute, final String value); List<String> listEntities(final String entityType); List<String> listTraits(final String guid); List<Struct> listTraitDefinitions(final String guid); Struct getTraitDefinition(final String guid, final String traitName); List<EntityAuditEvent> getEntityAuditEvents(String entityId, short numResults); List<EntityAuditEvent> getEntityAuditEvents(String entityId, String startKey, short numResults); JSONArray search(final String searchQuery, final int limit, final int offset); JSONArray searchByDSL(final String query, final int limit, final int offset); JSONObject searchByFullText(final String query, final int limit, final int offset); JSONObject getInputGraph(String datasetName); JSONObject getOutputGraph(String datasetName); JSONObject getInputGraphForEntity(String entityId); JSONObject getOutputGraphForEntity(String datasetId); JSONObject getSchemaForEntity(String datasetId); @VisibleForTesting JSONObject callAPIWithResource(API api, WebResource resource); @VisibleForTesting WebResource getResource(API api, String ... params); @VisibleForTesting JSONObject callAPIWithBody(API api, Object requestObject); @VisibleForTesting JSONObject callAPIWithBodyAndParams(API api, Object requestObject, String ... params); @VisibleForTesting JSONObject callAPIWithQueryParams(API api, MultivaluedMap<String, String> queryParams); static final String TYPE; static final String TYPENAME; static final String GUID; static final String ENTITIES; static final String GUID_ASSIGNMENTS; static final String DEFINITION; static final String ERROR; static final String STACKTRACE; static final String REQUEST_ID; static final String RESULTS; static final String COUNT; static final String ROWS; static final String DATATYPE; static final String STATUS; static final String EVENTS; static final String START_KEY; static final String NUM_RESULTS; static final String URI_ENTITY; static final String URI_ENTITY_AUDIT; static final String URI_SEARCH; static final String URI_NAME_LINEAGE; static final String URI_LINEAGE; static final String URI_TRAITS; static final String TRAITS; static final String TRAIT_DEFINITIONS; static final String QUERY; static final String LIMIT; static final String OFFSET; static final String QUERY_TYPE; static final String ATTRIBUTE_NAME; static final String ATTRIBUTE_VALUE; static final String SUPERTYPE; static final String NOT_SUPERTYPE; static final String ASSET_TYPE; static final String NAME; static final String DESCRIPTION; static final String OWNER; static final String INFRASTRUCTURE_SUPER_TYPE; static final String DATA_SET_SUPER_TYPE; static final String PROCESS_SUPER_TYPE; static final String PROCESS_ATTRIBUTE_INPUTS; static final String PROCESS_ATTRIBUTE_OUTPUTS; static final String REFERENCEABLE_SUPER_TYPE; static final String QUALIFIED_NAME; static final String REFERENCEABLE_ATTRIBUTE_NAME; static final String UNKNOWN_STATUS; }	@Test public void shouldGetAdminStatus() throws AtlasServiceException { setupRetryParams(); AtlasClient atlasClient = new AtlasClient(service, configuration); WebResource.Builder builder = setupBuilder(AtlasClient.API.STATUS, service); ClientResponse response = mock(ClientResponse.class); when(response.getStatus()).thenReturn(Response.Status.OK.getStatusCode()); String activeStatus = "{\"Status\":\"Active\"}"; when(response.getEntity(String.class)).thenReturn(activeStatus); when(response.getLength()).thenReturn(activeStatus.length()); when(builder.method(AtlasClient.API.STATUS.getMethod(), ClientResponse.class, null)).thenReturn(response); String status = atlasClient.getAdminStatus(); assertEquals(status, "Active"); }
getAppConfigurationEntry(String name)	InMemoryJAASConfiguration extends Configuration { @Override public AppConfigurationEntry[] getAppConfigurationEntry(String name) { if (LOG.isDebugEnabled()) { LOG.debug("==> InMemoryJAASConfiguration.getAppConfigurationEntry({})", name); } AppConfigurationEntry[] ret = null; List<AppConfigurationEntry> retList = null; String redirectedName = getConfigSectionRedirect(name); if (redirectedName != null) { retList = applicationConfigEntryMap.get(redirectedName); if (LOG.isDebugEnabled()) { LOG.debug("Redirected jaasConfigSection ({} -> {}): ", name, redirectedName, retList); } } if (retList == null \|\| retList.size() == 0) { retList = applicationConfigEntryMap.get(name); } if (retList == null \|\| retList.size() == 0) { if (parent != null) { ret = parent.getAppConfigurationEntry(name); } } else { int sz = retList.size(); ret = new AppConfigurationEntry[sz]; ret = retList.toArray(ret); } if (LOG.isDebugEnabled()) { LOG.debug("<== InMemoryJAASConfiguration.getAppConfigurationEntry({}): {}", name, ArrayUtils.toString(ret)); } return ret; } private InMemoryJAASConfiguration(Properties prop); static void init(String propFile); static void init(org.apache.commons.configuration.Configuration atlasConfiguration); static void init(Properties properties); @Override AppConfigurationEntry[] getAppConfigurationEntry(String name); static void setConfigSectionRedirect(String name, String redirectTo); }	@Test(enabled=false) public void testGetAppConfigurationEntryStringForMyClient() { AppConfigurationEntry[] entries = Configuration.getConfiguration().getAppConfigurationEntry("myClient"); Assert.assertNotNull(entries); Assert.assertEquals(2, entries.length); String principal = (String) entries[0].getOptions().get("principal"); Assert.assertNotNull(principal); String[] components = principal.split("[/@]"); Assert.assertEquals(3, components.length); Assert.assertEquals(true, StringUtils.equalsIgnoreCase(components[1], "abcd")); principal = (String) entries[1].getOptions().get("principal"); Assert.assertNotNull(principal); components = principal.split("[/@]"); Assert.assertEquals(2, components.length); }
getTraitNames(String guid)	GraphBackedMetadataRepository implements MetadataRepository { @Override @GraphTransaction public List<String> getTraitNames(String guid) throws AtlasException { if (LOG.isDebugEnabled()) { LOG.debug("Retrieving trait names for entity={}", guid); } AtlasVertex instanceVertex = graphHelper.getVertexForGUID(guid); return GraphHelper.getTraitNames(instanceVertex); } @Inject GraphBackedMetadataRepository(DeleteHandler deleteHandler, AtlasGraph atlasGraph); GraphToTypedInstanceMapper getGraphToInstanceMapper(); @Override String getTypeAttributeName(); @Override String getStateAttributeName(); @Override String getSuperTypeAttributeName(); String getIdAttributeName(); @Override String getVersionAttributeName(); @Override String getTraitLabel(IDataType<?> dataType, String traitName); @Override String getFieldNameInVertex(IDataType<?> dataType, AttributeInfo aInfo); String getFieldNameInVertex(IDataType<?> dataType, String attrName); @Override String getEdgeLabel(IDataType<?> dataType, AttributeInfo aInfo); @Override @GraphTransaction CreateUpdateEntitiesResult createEntities(ITypedReferenceableInstance... entities); @Override @GraphTransaction ITypedReferenceableInstance getEntityDefinition(String guid); @Override @GraphTransaction List<ITypedReferenceableInstance> getEntityDefinitions(String... guids); @Override @GraphTransaction ITypedReferenceableInstance getEntityDefinition(String entityType, String attribute, Object value); @Override @GraphTransaction List<String> getEntityList(String entityType); @Override @GraphTransaction List<String> getTraitNames(String guid); @Override @GraphTransaction void addTrait(List<String> entityGuids, ITypedStruct traitInstance); @Override @GraphTransaction void addTrait(String guid, ITypedStruct traitInstance); @Override @GraphTransaction void deleteTrait(String guid, String traitNameToBeDeleted); @Override @GraphTransaction CreateUpdateEntitiesResult updateEntities(ITypedReferenceableInstance... entitiesUpdated); @Override @GraphTransaction CreateUpdateEntitiesResult updatePartial(ITypedReferenceableInstance entity); @Override @GraphTransaction EntityResult deleteEntities(List<String> guids); AtlasGraph getGraph(); }	@Test(expectedExceptions = EntityNotFoundException.class) public void testGetTraitNamesForBadEntity() throws Exception { repositoryService.getTraitNames(UUID.randomUUID().toString()); Assert.fail(); }
getResourceById(Request request)	TaxonomyResourceProvider extends BaseResourceProvider implements ResourceProvider { @Override public Result getResourceById(Request request) throws ResourceNotFoundException { synchronized (TaxonomyResourceProvider.class) { createDefaultTaxonomyIfNeeded(); } return doGetResourceById(request); } TaxonomyResourceProvider(AtlasTypeSystem typeSystem); @Override Result getResourceById(Request request); @Override Result getResources(Request request); @Override void createResource(Request request); @Override Collection<String> createResources(Request request); @Override void deleteResourceById(Request request); @Override void updateResourceById(Request request); static final String DEFAULT_TAXONOMY_NAME; static final String DEFAULT_TAXONOMY_DESCRIPTION; static final String NAMESPACE_ATTRIBUTE_NAME; static final String TAXONOMY_TERM_TYPE; static final String TAXONOMY_NS; }	@Test(expectedExceptions = ResourceNotFoundException.class) public void testGetResourceById_404() throws Exception { AtlasTypeSystem typeSystem = createStrictMock(AtlasTypeSystem.class); QueryFactory queryFactory = createStrictMock(QueryFactory.class); AtlasQuery query = createStrictMock(AtlasQuery.class); Capture<Request> requestCapture = newCapture(); Collection<Map<String, Object>> emptyResponse = new ArrayList<>(); expect(queryFactory.createTaxonomyQuery(capture(requestCapture))).andReturn(query); expect(query.execute()).andReturn(emptyResponse); replay(typeSystem, queryFactory, query); TaxonomyResourceProvider provider = new TestTaxonomyResourceProvider(typeSystem); provider.setQueryFactory(queryFactory); Map<String, Object> requestProperties = new HashMap<>(); requestProperties.put("name", "taxonomyName"); Request request = new InstanceRequest(requestProperties); provider.getResourceById(request); verify(typeSystem, queryFactory, query); }
validateValue(Object obj, String objName, List<String> messages)	AtlasClassificationType extends AtlasStructType { @Override public boolean validateValue(Object obj, String objName, List<String> messages) { boolean ret = true; if (obj != null) { for (AtlasClassificationType superType : superTypes) { ret = superType.validateValue(obj, objName, messages) && ret; } ret = super.validateValue(obj, objName, messages) && ret; } return ret; } AtlasClassificationType(AtlasClassificationDef classificationDef); AtlasClassificationType(AtlasClassificationDef classificationDef, AtlasTypeRegistry typeRegistry); AtlasClassificationDef getClassificationDef(); @Override void resolveReferences(AtlasTypeRegistry typeRegistry); @Override void resolveReferencesPhase2(AtlasTypeRegistry typeRegistry); @Override void resolveReferencesPhase3(AtlasTypeRegistry typeRegistry); Set<String> getSuperTypes(); Set<String> getAllSuperTypes(); Set<String> getAllSubTypes(); Set<String> getTypeAndAllSubTypes(); String getTypeAndAllSubTypesQryStr(); boolean isSuperTypeOf(AtlasClassificationType classificationType); boolean isSuperTypeOf(String classificationName); boolean isSubTypeOf(AtlasClassificationType classificationType); boolean isSubTypeOf(String classificationName); @Override AtlasClassification createDefaultValue(); @Override boolean isValidValue(Object obj); @Override boolean isValidValueForUpdate(Object obj); @Override Object getNormalizedValue(Object obj); @Override Object getNormalizedValueForUpdate(Object obj); @Override boolean validateValue(Object obj, String objName, List<String> messages); @Override boolean validateValueForUpdate(Object obj, String objName, List<String> messages); void normalizeAttributeValues(AtlasClassification classification); void normalizeAttributeValuesForUpdate(AtlasClassification classification); @Override void normalizeAttributeValues(Map<String, Object> obj); void normalizeAttributeValuesForUpdate(Map<String, Object> obj); void populateDefaultValues(AtlasClassification classification); }	@Test public void testClassificationTypeValidateValue() { List<String> messages = new ArrayList<>(); for (Object value : validValues) { assertTrue(classificationType.validateValue(value, "testObj", messages)); assertEquals(messages.size(), 0, "value=" + value); } for (Object value : invalidValues) { assertFalse(classificationType.validateValue(value, "testObj", messages)); assertTrue(messages.size() > 0, "value=" + value); messages.clear(); } }
putAll(Collection<IDataType> types)	DefaultTypeCache implements TypeCache { @Override public void putAll(Collection<IDataType> types) throws AtlasException { for (IDataType type : types) { assertValidType(type); types_.put(type.getName(), type); } } @Override boolean has(String typeName); @Override boolean has(TypeCategory typeCategory, String typeName); @Override IDataType get(String typeName); @Override IDataType get(TypeCategory typeCategory, String typeName); @Override Collection<String> getTypeNames(Map<TYPE_FILTER, String> filterMap); @Override Collection<String> getAllTypeNames(); @Override void put(IDataType type); @Override void putAll(Collection<IDataType> types); @Override void remove(String typeName); @Override void remove(TypeCategory typeCategory, String typeName); @Override void clear(); @Override IDataType onTypeFault(String typeName); }	@Test(expectedExceptions = AtlasException.class) public void testCacheBulkInsertWithInvalidType() throws Exception { List<IDataType> allTypes = new ArrayList<>(); allTypes.add(DataTypes.BOOLEAN_TYPE); cache = new DefaultTypeCache(); cache.putAll(allTypes); fail("type should only one of ClassType \| EnumType \| StructType \| TraitType in 'putAll'"); }
getSchemaForEntity(String guid)	DataSetLineageService implements LineageService { @Override @GraphTransaction public String getSchemaForEntity(String guid) throws AtlasException { guid = ParamChecker.notEmpty(guid, "Entity id"); LOG.info("Fetching schema for entity guid={}", guid); String typeName = validateDatasetExists(guid); return getSchemaForId(typeName, guid); } @Inject DataSetLineageService(MetadataRepository metadataRepository, GraphBackedDiscoveryService discoveryService, AtlasGraph atlasGraph); @Override @GraphTransaction String getOutputsGraph(String datasetName); @Override @GraphTransaction String getInputsGraph(String tableName); @Override @GraphTransaction String getInputsGraphForEntity(String guid); @Override @GraphTransaction String getOutputsGraphForEntity(String guid); @Override @GraphTransaction String getSchema(String datasetName); @Override @GraphTransaction String getSchemaForEntity(String guid); static final String SELECT_INSTANCE_GUID; static final String DATASET_SCHEMA_QUERY_PREFIX; }	@Test(enabled = false) public void testGetSchemaForEntityInvalidArguments(final String entityId, String expectedException) throws Exception { testInvalidArguments(expectedException, new Invoker() { @Override void run() throws AtlasException { lineageService.getSchemaForEntity(entityId); } }); }
getActiveServerAddress()	ActiveInstanceState { public String getActiveServerAddress() { CuratorFramework client = curatorFactory.clientInstance(); String serverAddress = null; try { HAConfiguration.ZookeeperProperties zookeeperProperties = HAConfiguration.getZookeeperProperties(configuration); byte[] bytes = client.getData().forPath(getZnodePath(zookeeperProperties)); serverAddress = new String(bytes, Charset.forName("UTF-8")); } catch (Exception e) { LOG.error("Error getting active server address", e); } return serverAddress; } @Inject ActiveInstanceState(CuratorFactory curatorFactory); ActiveInstanceState(Configuration configuration, CuratorFactory curatorFactory); void update(String serverId); String getActiveServerAddress(); static final String APACHE_ATLAS_ACTIVE_SERVER_INFO; }	@Test public void testShouldReturnActiveServerAddress() throws Exception { when(curatorFactory.clientInstance()).thenReturn(curatorFramework); when(configuration.getString( HAConfiguration.ATLAS_SERVER_HA_ZK_ROOT_KEY, HAConfiguration.ATLAS_SERVER_ZK_ROOT_DEFAULT)). thenReturn(HAConfiguration.ATLAS_SERVER_ZK_ROOT_DEFAULT); GetDataBuilder getDataBuilder = mock(GetDataBuilder.class); when(curatorFramework.getData()).thenReturn(getDataBuilder); when(getDataBuilder.forPath(getPath())). thenReturn(SERVER_ADDRESS.getBytes(Charset.forName("UTF-8"))); ActiveInstanceState activeInstanceState = new ActiveInstanceState(configuration, curatorFactory); String actualServerAddress = activeInstanceState.getActiveServerAddress(); assertEquals(SERVER_ADDRESS, actualServerAddress); }
createAtlasTopic(Configuration atlasProperties, String... topicNames)	AtlasTopicCreator { public void createAtlasTopic(Configuration atlasProperties, String... topicNames) { if (atlasProperties.getBoolean(ATLAS_NOTIFICATION_CREATE_TOPICS_KEY, true)) { if (!handleSecurity(atlasProperties)) { return; } ZkUtils zkUtils = createZkUtils(atlasProperties); for (String topicName : topicNames) { try { LOG.warn("Attempting to create topic {}", topicName); if (!ifTopicExists(topicName, zkUtils)) { createTopic(atlasProperties, topicName, zkUtils); } else { LOG.warn("Ignoring call to create topic {}, as it already exists.", topicName); } } catch (Throwable t) { LOG.error("Failed while creating topic {}", topicName, t); } } zkUtils.close(); } else { LOG.info("Not creating topics {} as {} is false", StringUtils.join(topicNames, ","), ATLAS_NOTIFICATION_CREATE_TOPICS_KEY); } } void createAtlasTopic(Configuration atlasProperties, String... topicNames); static void main(String[] args); static final String ATLAS_NOTIFICATION_CREATE_TOPICS_KEY; }	@Test public void shouldNotCreateTopicIfItAlreadyExists() { Configuration configuration = mock(Configuration.class); when(configuration.getBoolean(AtlasTopicCreator.ATLAS_NOTIFICATION_CREATE_TOPICS_KEY, true)). thenReturn(true); when(configuration.getString("atlas.authentication.method.kerberos")).thenReturn("false"); final ZkUtils zookeeperUtils = mock(ZkUtils.class); final boolean[] topicExistsCalled = new boolean[]{false}; final boolean[] createTopicCalled = new boolean[]{false}; AtlasTopicCreator atlasTopicCreator = new AtlasTopicCreator() { @Override protected boolean ifTopicExists(String topicName, ZkUtils zkUtils) { topicExistsCalled[0] = true; return true; } @Override protected ZkUtils createZkUtils(Configuration atlasProperties) { return zookeeperUtils; } @Override protected void createTopic(Configuration atlasProperties, String topicName, ZkUtils zkUtils) { createTopicCalled[0] = true; } }; atlasTopicCreator.createAtlasTopic(configuration, "ATLAS_HOOK"); assertTrue(topicExistsCalled[0]); assertFalse(createTopicCalled[0]); }
getVersionParts()	MessageVersion implements Comparable<MessageVersion> { protected Integer[] getVersionParts() { String[] sParts = version.split("\\."); ArrayList<Integer> iParts = new ArrayList<>(); int trailingZeros = 0; for (String sPart : sParts) { Integer iPart = new Integer(sPart); if (iPart == 0) { ++trailingZeros; } else { for (int i = 0; i < trailingZeros; ++i) { iParts.add(0); } trailingZeros = 0; iParts.add(iPart); } } return iParts.toArray(new Integer[iParts.size()]); } MessageVersion(String version); @Override int compareTo(MessageVersion that); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static final MessageVersion NO_VERSION; }	@Test public void testGetVersionParts() throws Exception { MessageVersion version = new MessageVersion("1.0.0"); assertTrue(Arrays.equals(new Integer[]{1}, version.getVersionParts())); version = new MessageVersion("1.0"); assertTrue(Arrays.equals(new Integer[]{1}, version.getVersionParts())); version = new MessageVersion("1"); assertTrue(Arrays.equals(new Integer[]{1}, version.getVersionParts())); version = new MessageVersion("1.0.2"); assertTrue(Arrays.equals(new Integer[]{1, 0, 2}, version.getVersionParts())); }
validateCreatePayload(Request request)	TermResourceDefinition extends BaseResourceDefinition { @Override public void validateCreatePayload(Request request) throws InvalidPayloadException { super.validateCreatePayload(request); String name = request.getProperty("name"); if (! name.contains(".")) { throw new InvalidPayloadException("Term name must be in the form 'taxonomyName.termName.subTermName'"); } if (! request.getQueryProperties().containsKey("available_as_tag")) { request.getQueryProperties().put("available_as_tag", true); } } TermResourceDefinition(); @Override void validateCreatePayload(Request request); @Override String getTypeName(); @Override String getIdPropertyName(); @Override String resolveHref(Map<String, Object> properties); }	@Test public void testValidate_nameOnly() throws Exception { Map<String, Object> properties = new HashMap<>(); properties.put("name", "taxonomy1.termName"); Request request = new InstanceRequest(properties); ResourceDefinition termDefinition = new TermResourceDefinition(); termDefinition.validateCreatePayload(request); }
validateCreatePayload(Request request)	TermResourceDefinition extends BaseResourceDefinition { @Override public void validateCreatePayload(Request request) throws InvalidPayloadException { super.validateCreatePayload(request); String name = request.getProperty("name"); if (! name.contains(".")) { throw new InvalidPayloadException("Term name must be in the form 'taxonomyName.termName.subTermName'"); } if (! request.getQueryProperties().containsKey("available_as_tag")) { request.getQueryProperties().put("available_as_tag", true); } } TermResourceDefinition(); @Override void validateCreatePayload(Request request); @Override String getTypeName(); @Override String getIdPropertyName(); @Override String resolveHref(Map<String, Object> properties); }	@Test public void testValidate() throws Exception { Map<String, Object> properties = new HashMap<>(); properties.put("name", "taxonomy1.termName"); properties.put("description", "foo"); properties.put("available_as_tag", true); properties.put("acceptable_use", "something"); Request request = new InstanceRequest(properties); ResourceDefinition termDefinition = new TermResourceDefinition(); termDefinition.validateCreatePayload(request); }
notifyEntitiesInternal(List<HookNotification.HookNotificationMessage> messages, int maxRetries, NotificationInterface notificationInterface, boolean shouldLogFailedMessages, FailedMessagesLogger logger)	AtlasHook { @VisibleForTesting static void notifyEntitiesInternal(List<HookNotification.HookNotificationMessage> messages, int maxRetries, NotificationInterface notificationInterface, boolean shouldLogFailedMessages, FailedMessagesLogger logger) { if (messages == null \|\| messages.isEmpty()) { return; } final String message = messages.toString(); int numRetries = 0; while (true) { try { notificationInterface.send(NotificationInterface.NotificationType.HOOK, messages); return; } catch (Exception e) { numRetries++; if (numRetries < maxRetries) { LOG.error("Failed to send notification - attempt #{}; error={}", numRetries, e.getMessage()); try { LOG.debug("Sleeping for {} ms before retry", notificationRetryInterval); Thread.sleep(notificationRetryInterval); } catch (InterruptedException ie) { LOG.error("Notification hook thread sleep interrupted"); } } else { if (shouldLogFailedMessages && e instanceof NotificationException) { List<String> failedMessages = ((NotificationException) e).getFailedMessages(); for (String msg : failedMessages) { logger.log(msg); } } LOG.error("Failed to notify atlas for entity {} after {} retries. Quitting", message, maxRetries, e); return; } } } } static void notifyEntities(List<HookNotification.HookNotificationMessage> messages, int maxRetries); static String getUser(); static String getUser(String userName); static String getUser(String userName, UserGroupInformation ugi); static final String ATLAS_NOTIFICATION_RETRY_INTERVAL; static final String ATLAS_NOTIFICATION_FAILED_MESSAGES_FILENAME_KEY; static final String ATLAS_HOOK_FAILED_MESSAGES_LOG_DEFAULT_NAME; static final String ATLAS_NOTIFICATION_LOG_FAILED_MESSAGES_ENABLED_KEY; }	@Test (timeOut = 10000) public void testNotifyEntitiesDoesNotHangOnException() throws Exception { List<HookNotification.HookNotificationMessage> hookNotificationMessages = new ArrayList<>(); doThrow(new NotificationException(new Exception())).when(notificationInterface) .send(NotificationInterface.NotificationType.HOOK, hookNotificationMessages); AtlasHook.notifyEntitiesInternal(hookNotificationMessages, 0, notificationInterface, false, failedMessagesLogger); }
createOrUpdate(EntityStream entityStream, boolean isPartialUpdate, boolean replaceClassifications)	AtlasEntityStoreV1 implements AtlasEntityStore { private EntityMutationResponse createOrUpdate(EntityStream entityStream, boolean isPartialUpdate, boolean replaceClassifications) throws AtlasBaseException { if (LOG.isDebugEnabled()) { LOG.debug("==> createOrUpdate()"); } if (entityStream == null \|\| !entityStream.hasNext()) { throw new AtlasBaseException(AtlasErrorCode.INVALID_PARAMETERS, "no entities to create/update."); } EntityMutationContext context = preCreateOrUpdate(entityStream, entityGraphMapper, isPartialUpdate); EntityMutationResponse ret = entityGraphMapper.mapAttributesAndClassifications(context, isPartialUpdate, replaceClassifications); ret.setGuidAssignments(context.getGuidAssignments()); if (LOG.isDebugEnabled()) { LOG.debug("<== createOrUpdate()"); } entityChangeNotifier.onEntitiesMutated(ret, entityStream instanceof EntityImportStream); return ret; } @Inject AtlasEntityStoreV1(DeleteHandlerV1 deleteHandler, AtlasTypeRegistry typeRegistry, AtlasEntityChangeNotifier entityChangeNotifier, EntityGraphMapper entityGraphMapper); @Override @GraphTransaction AtlasEntityWithExtInfo getById(String guid); @Override @GraphTransaction AtlasEntitiesWithExtInfo getByIds(List<String> guids); @Override @GraphTransaction AtlasEntityWithExtInfo getByUniqueAttributes(AtlasEntityType entityType, Map<String, Object> uniqAttributes); @Override @GraphTransaction EntityMutationResponse bulkImport(EntityImportStream entityStream, AtlasImportResult importResult); @Override @GraphTransaction EntityMutationResponse createOrUpdate(EntityStream entityStream, boolean isPartialUpdate); @Override @GraphTransaction EntityMutationResponse updateByUniqueAttributes(AtlasEntityType entityType, Map<String, Object> uniqAttributes, AtlasEntityWithExtInfo updatedEntityInfo); @Override @GraphTransaction EntityMutationResponse updateEntityAttributeByGuid(String guid, String attrName, Object attrValue); @Override @GraphTransaction EntityMutationResponse deleteById(final String guid); @Override @GraphTransaction EntityMutationResponse deleteByIds(final List<String> guids); @Override @GraphTransaction EntityMutationResponse deleteByUniqueAttributes(AtlasEntityType entityType, Map<String, Object> uniqAttributes); @Override @GraphTransaction void addClassifications(final String guid, final List<AtlasClassification> classifications); @Override @GraphTransaction void updateClassifications(String guid, List<AtlasClassification> newClassifications); @Override @GraphTransaction void addClassification(final List<String> guids, final AtlasClassification classification); @Override @GraphTransaction void deleteClassifications(final String guid, final List<String> classificationNames); @Override @GraphTransaction List<AtlasClassification> getClassifications(String guid); @Override @GraphTransaction AtlasClassification getClassification(String guid, String classificationName); }	@Test public void testSetObjectIdAttrToNull() throws Exception { final AtlasEntity dbEntity = TestUtilsV2.createDBEntity(); final AtlasEntity db2Entity = TestUtilsV2.createDBEntity(); entityStore.createOrUpdate(new AtlasEntityStream(dbEntity), false); entityStore.createOrUpdate(new AtlasEntityStream(db2Entity), false); final AtlasEntity tableEntity = TestUtilsV2.createTableEntity(dbEntity); tableEntity.setAttribute("databaseComposite", AtlasTypeUtil.getAtlasObjectId(db2Entity)); final EntityMutationResponse tblCreationResponse = entityStore.createOrUpdate(new AtlasEntityStream(tableEntity), false); final AtlasEntityHeader createdTblHeader = tblCreationResponse.getCreatedEntityByTypeNameAndAttribute(TABLE_TYPE, NAME, (String) tableEntity.getAttribute(NAME)); final AtlasEntity createdTblEntity = getEntityFromStore(createdTblHeader); init(); createdTblEntity.setAttribute("databaseComposite", null); final EntityMutationResponse tblUpdateResponse = entityStore.createOrUpdate(new AtlasEntityStream(createdTblEntity), true); final AtlasEntityHeader updatedTblHeader = tblUpdateResponse.getFirstEntityPartialUpdated(); final AtlasEntity updatedTblEntity = getEntityFromStore(updatedTblHeader); final AtlasEntity deletedDb2Entity = getEntityFromStore(db2Entity.getGuid()); assertEquals(deletedDb2Entity.getStatus(), AtlasEntity.Status.DELETED); }
doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)	ActiveServerFilter implements Filter { @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { if (isFilteredURI(servletRequest)) { LOG.debug("Is a filtered URI: {}. Passing request downstream.", ((HttpServletRequest)servletRequest).getRequestURI()); filterChain.doFilter(servletRequest, servletResponse); } else if (isInstanceActive()) { LOG.debug("Active. Passing request downstream"); filterChain.doFilter(servletRequest, servletResponse); } else if (serviceState.isInstanceInTransition()) { HttpServletResponse httpServletResponse = (HttpServletResponse) servletResponse; LOG.error("Instance in transition. Service may not be ready to return a result"); httpServletResponse.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE); } else { HttpServletResponse httpServletResponse = (HttpServletResponse) servletResponse; String activeServerAddress = activeInstanceState.getActiveServerAddress(); if (activeServerAddress == null) { LOG.error("Could not retrieve active server address as it is null. Cannot redirect request {}", ((HttpServletRequest)servletRequest).getRequestURI()); httpServletResponse.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE); } else { handleRedirect((HttpServletRequest) servletRequest, httpServletResponse, activeServerAddress); } } } @Inject ActiveServerFilter(ActiveInstanceState activeInstanceState, ServiceState serviceState); @Override void init(FilterConfig filterConfig); @Override void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain); @Override void destroy(); }	@Test public void testShouldRedirectPUTRequest() throws IOException, ServletException { when(serviceState.getState()).thenReturn(ServiceState.ServiceStateValue.PASSIVE); when(servletRequest.getRequestURI()).thenReturn("api/atlas/types"); ActiveServerFilter activeServerFilter = new ActiveServerFilter(activeInstanceState, serviceState); when(activeInstanceState.getActiveServerAddress()).thenReturn(ACTIVE_SERVER_ADDRESS); when(servletRequest.getMethod()).thenReturn(HttpMethod.PUT); when(servletRequest.getRequestURI()).thenReturn("types"); activeServerFilter.doFilter(servletRequest, servletResponse, filterChain); verify(servletResponse).setHeader("Location", ACTIVE_SERVER_ADDRESS+"types"); verify(servletResponse).setStatus(HttpServletResponse.SC_TEMPORARY_REDIRECT); }
doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)	AuditFilter implements Filter { @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException { final String requestTimeISO9601 = DateTimeHelper.formatDateUTC(new Date()); final HttpServletRequest httpRequest = (HttpServletRequest) request; final String requestId = UUID.randomUUID().toString(); final Thread currentThread = Thread.currentThread(); final String oldName = currentThread.getName(); String user = getUserFromRequest(httpRequest); try { currentThread.setName(formatName(oldName, requestId)); RequestContext requestContext = RequestContext.createContext(); requestContext.setUser(user); recordAudit(httpRequest, requestTimeISO9601, user); filterChain.doFilter(request, response); } finally { ((HttpServletResponse) response).setHeader(AtlasClient.REQUEST_ID, requestId); currentThread.setName(oldName); recordMetrics(); RequestContext.clear(); RequestContextV1.clear(); } } @Override void init(FilterConfig filterConfig); @Override void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain); static void audit(String who, String fromAddress, String whatRequest, String fromHost, String whatURL, String whatAddrs, String whenISO9601); static void recordMetrics(); @Override void destroy(); }	@Test public void testAuditWithExcludedOperation() throws IOException, ServletException { AtlasRepositoryConfiguration.resetExcludedOperations(); when(configuration.getStringArray(AtlasRepositoryConfiguration.AUDIT_EXCLUDED_OPERATIONS)).thenReturn(new String[]{"GET:Version", "GET:Ping"}); when(servletRequest.getRequestURL()).thenReturn(new StringBuffer("api/atlas/version")); when(servletRequest.getMethod()).thenReturn("GET"); AuditFilter auditFilter = new AuditFilter(); auditFilter.doFilter(servletRequest, servletResponse, filterChain); verify(filterChain).doFilter(servletRequest, servletResponse); }
getOperationType()	EntityNotificationImpl implements EntityNotification { @Override public OperationType getOperationType() { return operationType; } @SuppressWarnings("unused") private EntityNotificationImpl(); EntityNotificationImpl(Referenceable entity, OperationType operationType, List<IStruct> traits); EntityNotificationImpl(Referenceable entity, OperationType operationType, TypeSystem typeSystem); @Override IReferenceableInstance getEntity(); @Override List<IStruct> getAllTraits(); @Override OperationType getOperationType(); @Override boolean equals(Object o); @Override int hashCode(); }	@Test public void testGetOperationType() throws Exception { Referenceable entity = getEntity("id"); EntityNotificationImpl entityNotification = new EntityNotificationImpl(entity, EntityNotification.OperationType.ENTITY_CREATE, Collections.<IStruct>emptyList()); assertEquals(EntityNotification.OperationType.ENTITY_CREATE, entityNotification.getOperationType()); }
getTraitNames(String guid)	GraphBackedMetadataRepository implements MetadataRepository { @Override @GraphTransaction public List<String> getTraitNames(String guid) throws AtlasException { if (LOG.isDebugEnabled()) { LOG.debug("Retrieving trait names for entity={}", guid); } AtlasVertex instanceVertex = graphHelper.getVertexForGUID(guid); return GraphHelper.getTraitNames(instanceVertex); } @Inject GraphBackedMetadataRepository(DeleteHandler deleteHandler, AtlasGraph atlasGraph); GraphToTypedInstanceMapper getGraphToInstanceMapper(); @Override String getTypeAttributeName(); @Override String getStateAttributeName(); @Override String getSuperTypeAttributeName(); String getIdAttributeName(); @Override String getVersionAttributeName(); @Override String getTraitLabel(IDataType<?> dataType, String traitName); @Override String getFieldNameInVertex(IDataType<?> dataType, AttributeInfo aInfo); String getFieldNameInVertex(IDataType<?> dataType, String attrName); @Override String getEdgeLabel(IDataType<?> dataType, AttributeInfo aInfo); @Override @GraphTransaction CreateUpdateEntitiesResult createEntities(ITypedReferenceableInstance... entities); @Override @GraphTransaction ITypedReferenceableInstance getEntityDefinition(String guid); @Override @GraphTransaction List<ITypedReferenceableInstance> getEntityDefinitions(String... guids); @Override @GraphTransaction ITypedReferenceableInstance getEntityDefinition(String entityType, String attribute, Object value); @Override @GraphTransaction List<String> getEntityList(String entityType); @Override @GraphTransaction List<String> getTraitNames(String guid); @Override @GraphTransaction void addTrait(List<String> entityGuids, ITypedStruct traitInstance); @Override @GraphTransaction void addTrait(String guid, ITypedStruct traitInstance); @Override @GraphTransaction void deleteTrait(String guid, String traitNameToBeDeleted); @Override @GraphTransaction CreateUpdateEntitiesResult updateEntities(ITypedReferenceableInstance... entitiesUpdated); @Override @GraphTransaction CreateUpdateEntitiesResult updatePartial(ITypedReferenceableInstance entity); @Override @GraphTransaction EntityResult deleteEntities(List<String> guids); AtlasGraph getGraph(); }	@Test public void testGetTraitNamesForEmptyTraits() throws Exception { final List<String> traitNames = repositoryService.getTraitNames(guid); Assert.assertEquals(traitNames.size(), 0); }
getEntityDefinition(String guid)	GraphBackedMetadataRepository implements MetadataRepository { @Override @GraphTransaction public ITypedReferenceableInstance getEntityDefinition(String guid) throws RepositoryException, EntityNotFoundException { return getEntityDefinitions(guid).get(0); } @Inject GraphBackedMetadataRepository(DeleteHandler deleteHandler, AtlasGraph atlasGraph); GraphToTypedInstanceMapper getGraphToInstanceMapper(); @Override String getTypeAttributeName(); @Override String getStateAttributeName(); @Override String getSuperTypeAttributeName(); String getIdAttributeName(); @Override String getVersionAttributeName(); @Override String getTraitLabel(IDataType<?> dataType, String traitName); @Override String getFieldNameInVertex(IDataType<?> dataType, AttributeInfo aInfo); String getFieldNameInVertex(IDataType<?> dataType, String attrName); @Override String getEdgeLabel(IDataType<?> dataType, AttributeInfo aInfo); @Override @GraphTransaction CreateUpdateEntitiesResult createEntities(ITypedReferenceableInstance... entities); @Override @GraphTransaction ITypedReferenceableInstance getEntityDefinition(String guid); @Override @GraphTransaction List<ITypedReferenceableInstance> getEntityDefinitions(String... guids); @Override @GraphTransaction ITypedReferenceableInstance getEntityDefinition(String entityType, String attribute, Object value); @Override @GraphTransaction List<String> getEntityList(String entityType); @Override @GraphTransaction List<String> getTraitNames(String guid); @Override @GraphTransaction void addTrait(List<String> entityGuids, ITypedStruct traitInstance); @Override @GraphTransaction void addTrait(String guid, ITypedStruct traitInstance); @Override @GraphTransaction void deleteTrait(String guid, String traitNameToBeDeleted); @Override @GraphTransaction CreateUpdateEntitiesResult updateEntities(ITypedReferenceableInstance... entitiesUpdated); @Override @GraphTransaction CreateUpdateEntitiesResult updatePartial(ITypedReferenceableInstance entity); @Override @GraphTransaction EntityResult deleteEntities(List<String> guids); AtlasGraph getGraph(); }	@Test(dependsOnMethods = "testSubmitEntity") public void testGetEntityDefinitionForDepartment() throws Exception { ITypedReferenceableInstance entity = repositoryService.getEntityDefinition(guid); Assert.assertNotNull(entity); Assert.assertEquals(entity.getId().getState(), Id.EntityState.ACTIVE); AtlasSystemAttributes systemAttributes = entity.getSystemAttributes(); Assert.assertNotNull(systemAttributes.createdTime); Assert.assertNotNull(systemAttributes.modifiedTime); }
createTaxonomyQuery(Request request)	QueryFactory { public AtlasQuery createTaxonomyQuery(Request request) throws InvalidQueryException { ResourceDefinition taxonomyDefinition = new TaxonomyResourceDefinition(); QueryExpression queryExpression = create(request, taxonomyDefinition); return new AtlasTaxonomyQuery(queryExpression, taxonomyDefinition, request); } QueryFactory(); AtlasQuery createTaxonomyQuery(Request request); AtlasQuery createTermQuery(Request request); AtlasQuery createEntityQuery(Request request); AtlasQuery createEntityTagQuery(Request request); static final String PATH_SEP_TOKEN; }	@Test public void testCreateTaxonomyQuery() throws Exception { Map<String, Object> requestProps = new HashMap<>(); requestProps.put("name", "test_taxonomy"); Request request = new InstanceRequest(requestProps); QueryFactory factory = new QueryFactory(); AtlasTaxonomyQuery query = (AtlasTaxonomyQuery) factory.createTaxonomyQuery(request); QueryExpression queryExpression = query.getQueryExpression(); assertEquals(queryExpression.getClass(), TermQueryExpression.class); assertEquals(queryExpression.getField(), "name"); assertEquals(queryExpression.getExpectedValue(), "test_taxonomy"); assertEquals(query.getRequest(), request); assertEquals(query.getResourceDefinition().getTypeName(), "Taxonomy"); }
apply(AtlasEntity.AtlasEntityWithExtInfo entityWithExtInfo)	ImportTransforms { public AtlasEntity.AtlasEntityWithExtInfo apply(AtlasEntity.AtlasEntityWithExtInfo entityWithExtInfo) throws AtlasBaseException { if (entityWithExtInfo != null) { apply(entityWithExtInfo.getEntity()); if(MapUtils.isNotEmpty(entityWithExtInfo.getReferredEntities())) { for (AtlasEntity e : entityWithExtInfo.getReferredEntities().values()) { apply(e); } } } return entityWithExtInfo; } private ImportTransforms(); private ImportTransforms(String jsonString); static ImportTransforms fromJson(String jsonString); Map<String, Map<String, List<ImportTransformer>>> getTransforms(); Map<String, List<ImportTransformer>> getTransforms(String typeName); AtlasEntity.AtlasEntityWithExtInfo apply(AtlasEntity.AtlasEntityWithExtInfo entityWithExtInfo); AtlasEntity apply(AtlasEntity entity); }	@Test public void transformEntityWithExtInfo() throws AtlasBaseException { addColumnTransform(transform); AtlasEntityWithExtInfo entityWithExtInfo = getAtlasEntityWithExtInfo(); AtlasEntity entity = entityWithExtInfo.getEntity(); String attrValue = (String) entity.getAttribute(qualifiedName); String[] expectedValues = getExtEntityExpectedValues(entityWithExtInfo); transform.apply(entityWithExtInfo); assertEquals(entityWithExtInfo.getEntity().getAttribute(qualifiedName), applyDefaultTransform(attrValue)); for (int i = 0; i < expectedValues.length; i++) { assertEquals(entityWithExtInfo.getReferredEntities().get(Integer.toString(i)).getAttribute(qualifiedName), expectedValues[i]); } }
remove(String typeName)	DefaultTypeCache implements TypeCache { @Override public void remove(String typeName) throws AtlasException { types_.remove(typeName); } @Override boolean has(String typeName); @Override boolean has(TypeCategory typeCategory, String typeName); @Override IDataType get(String typeName); @Override IDataType get(TypeCategory typeCategory, String typeName); @Override Collection<String> getTypeNames(Map<TYPE_FILTER, String> filterMap); @Override Collection<String> getAllTypeNames(); @Override void put(IDataType type); @Override void putAll(Collection<IDataType> types); @Override void remove(String typeName); @Override void remove(TypeCategory typeCategory, String typeName); @Override void clear(); @Override IDataType onTypeFault(String typeName); }	@Test(expectedExceptions = IllegalArgumentException.class) public void testCacheRemoveByNullCategory() throws Exception { cache.remove(null, CLASSTYPE_CUSTOMER); fail("Null type should be not allowed in 'remove'"); }
get(String typeName)	DefaultTypeCache implements TypeCache { @Override public IDataType get(String typeName) throws AtlasException { return types_.get(typeName); } @Override boolean has(String typeName); @Override boolean has(TypeCategory typeCategory, String typeName); @Override IDataType get(String typeName); @Override IDataType get(TypeCategory typeCategory, String typeName); @Override Collection<String> getTypeNames(Map<TYPE_FILTER, String> filterMap); @Override Collection<String> getAllTypeNames(); @Override void put(IDataType type); @Override void putAll(Collection<IDataType> types); @Override void remove(String typeName); @Override void remove(TypeCategory typeCategory, String typeName); @Override void clear(); @Override IDataType onTypeFault(String typeName); }	@Test public void testCacheGetTypeByCategory() throws Exception { IDataType custType = cache.get(TypeCategory.CLASS, CLASSTYPE_CUSTOMER); verifyType(custType, CLASSTYPE_CUSTOMER, ClassType.class); IDataType addrType = cache.get(TypeCategory.STRUCT, STRUCTTYPE_ADDRESS); verifyType(addrType, STRUCTTYPE_ADDRESS, StructType.class); IDataType privTrait = cache.get(TypeCategory.TRAIT, TRAITTYPE_PRIVILEGED); verifyType(privTrait, TRAITTYPE_PRIVILEGED, TraitType.class); IDataType shippingEnum = cache.get(TypeCategory.ENUM, ENUMTYPE_SHIPPING); verifyType(shippingEnum, ENUMTYPE_SHIPPING, EnumType.class); assertNull(cache.get(UNKNOWN_TYPE)); }
getCardinality()	CollectionRequest extends BaseRequest { @Override public Cardinality getCardinality() { return Cardinality.COLLECTION; } CollectionRequest(Map<String, Object> queryProperties, String queryString); CollectionRequest(Map<String, Object> queryProperties, String queryString, Map<String, Object> updateProperties); @Override Cardinality getCardinality(); }	@Test public void testNoProperties() { String query = "name:foo*"; Request request = new CollectionRequest(null, query); assertEquals(Request.Cardinality.COLLECTION, request.getCardinality()); assertTrue(request.getQueryProperties().isEmpty()); assertNull(request.getProperty("foo")); assertTrue(request.getAdditionalSelectProperties().isEmpty()); }
isOperationExcludedFromAudit(String requestHttpMethod, String requestOperation, Configuration config)	AuditFilter implements Filter { boolean isOperationExcludedFromAudit(String requestHttpMethod, String requestOperation, Configuration config) { try { return AtlasRepositoryConfiguration.isExcludedFromAudit(config, requestHttpMethod, requestOperation); } catch (AtlasException e) { return false; } } @Override void init(FilterConfig filterConfig); @Override void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain); static void audit(String who, String fromAddress, String whatRequest, String fromHost, String whatURL, String whatAddrs, String whenISO9601); static void recordMetrics(); @Override void destroy(); }	@Test public void testVerifyExcludedOperations() { AtlasRepositoryConfiguration.resetExcludedOperations(); when(configuration.getStringArray(AtlasRepositoryConfiguration.AUDIT_EXCLUDED_OPERATIONS)).thenReturn(new String[]{"GET:Version", "GET:Ping"}); AuditFilter auditFilter = new AuditFilter(); assertTrue(auditFilter.isOperationExcludedFromAudit("GET", "Version", configuration)); assertTrue(auditFilter.isOperationExcludedFromAudit("get", "Version", configuration)); assertTrue(auditFilter.isOperationExcludedFromAudit("GET", "Ping", configuration)); assertFalse(auditFilter.isOperationExcludedFromAudit("GET", "Types", configuration)); }
validateValue(Object obj, String objName, List<String> messages)	AtlasArrayType extends AtlasType { @Override public boolean validateValue(Object obj, String objName, List<String> messages) { boolean ret = true; if (obj != null) { if (obj instanceof List \|\| obj instanceof Set) { Collection objList = (Collection) obj; if (!isValidElementCount(objList.size())) { ret = false; messages.add(objName + ": incorrect number of values. found=" + objList.size() + "; expected: minCount=" + minCount + ", maxCount=" + maxCount); } int idx = 0; for (Object element : objList) { ret = elementType.validateValue(element, objName + "[" + idx + "]", messages) && ret; idx++; } } else if (obj.getClass().isArray()) { int arrayLen = Array.getLength(obj); if (!isValidElementCount(arrayLen)) { ret = false; messages.add(objName + ": incorrect number of values. found=" + arrayLen + "; expected: minCount=" + minCount + ", maxCount=" + maxCount); } for (int i = 0; i < arrayLen; i++) { ret = elementType.validateValue(Array.get(obj, i), objName + "[" + i + "]", messages) && ret; } } else { ret = false; messages.add(objName + "=" + obj + ": invalid value for type " + getTypeName()); } } return ret; } AtlasArrayType(AtlasType elementType); AtlasArrayType(AtlasType elementType, int minCount, int maxCount); AtlasArrayType(String elementTypeName); AtlasArrayType(String elementTypeName, int minCount, int maxCount); AtlasArrayType(String elementTypeName, AtlasTypeRegistry typeRegistry); AtlasArrayType(String elementTypeName, int minCount, int maxCount, AtlasTypeRegistry typeRegistry); String getElementTypeName(); void setMinCount(int minCount); int getMinCount(); void setMaxCount(int maxCount); int getMaxCount(); AtlasType getElementType(); @Override void resolveReferences(AtlasTypeRegistry typeRegistry); @Override Collection<?> createDefaultValue(); @Override boolean isValidValue(Object obj); @Override boolean isValidValueForUpdate(Object obj); @Override Collection<?> getNormalizedValue(Object obj); @Override Collection<?> getNormalizedValueForUpdate(Object obj); @Override boolean validateValue(Object obj, String objName, List<String> messages); @Override boolean validateValueForUpdate(Object obj, String objName, List<String> messages); @Override AtlasType getTypeForAttribute(); }	@Test public void testArrayTypeValidateValue() { List<String> messages = new ArrayList<>(); for (Object value : validValues) { assertTrue(intArrayType.validateValue(value, "testObj", messages)); assertEquals(messages.size(), 0, "value=" + value); } for (Object value : invalidValues) { assertFalse(intArrayType.validateValue(value, "testObj", messages)); assertTrue(messages.size() > 0, "value=" + value); messages.clear(); } }
compareTo(MessageVersion that)	MessageVersion implements Comparable<MessageVersion> { @Override public int compareTo(MessageVersion that) { if (that == null) { return 1; } Integer[] thisParts = getVersionParts(); Integer[] thatParts = that.getVersionParts(); int length = Math.max(thisParts.length, thatParts.length); for (int i = 0; i < length; i++) { int comp = getVersionPart(thisParts, i) - getVersionPart(thatParts, i); if (comp != 0) { return comp; } } return 0; } MessageVersion(String version); @Override int compareTo(MessageVersion that); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static final MessageVersion NO_VERSION; }	@Test public void testCompareTo() throws Exception { MessageVersion version1 = new MessageVersion("1.0.0"); MessageVersion version2 = new MessageVersion("1.0.0"); MessageVersion version3 = new MessageVersion("2.0.0"); MessageVersion version4 = new MessageVersion("1"); MessageVersion version5 = new MessageVersion("1.5"); MessageVersion version6 = new MessageVersion("1.0.5"); assertTrue(version1.compareTo(version2) == 0); assertTrue(version2.compareTo(version1) == 0); assertTrue(version1.compareTo(version3) < 0); assertTrue(version3.compareTo(version1) > 0); assertTrue(version1.compareTo(version4) == 0); assertTrue(version4.compareTo(version1) == 0); assertTrue(version1.compareTo(version5) < 0); assertTrue(version5.compareTo(version1) > 0); assertTrue(version1.compareTo(version6) < 0); assertTrue(version6.compareTo(version1) > 0); }
update(String serverId)	ActiveInstanceState { public void update(String serverId) throws AtlasBaseException { try { CuratorFramework client = curatorFactory.clientInstance(); HAConfiguration.ZookeeperProperties zookeeperProperties = HAConfiguration.getZookeeperProperties(configuration); String atlasServerAddress = HAConfiguration.getBoundAddressForId(configuration, serverId); List<ACL> acls = Arrays.asList( new ACL[]{AtlasZookeeperSecurityProperties.parseAcl(zookeeperProperties.getAcl(), ZooDefs.Ids.OPEN_ACL_UNSAFE.get(0))}); Stat serverInfo = client.checkExists().forPath(getZnodePath(zookeeperProperties)); if (serverInfo == null) { client.create(). withMode(CreateMode.EPHEMERAL). withACL(acls). forPath(getZnodePath(zookeeperProperties)); } client.setData().forPath(getZnodePath(zookeeperProperties), atlasServerAddress.getBytes(Charset.forName("UTF-8"))); } catch (Exception e) { throw new AtlasBaseException(AtlasErrorCode.CURATOR_FRAMEWORK_UPDATE, e, "forPath: getZnodePath"); } } @Inject ActiveInstanceState(CuratorFactory curatorFactory); ActiveInstanceState(Configuration configuration, CuratorFactory curatorFactory); void update(String serverId); String getActiveServerAddress(); static final String APACHE_ATLAS_ACTIVE_SERVER_INFO; }	@Test public void testSharedPathIsCreatedIfNotExists() throws Exception { when(configuration.getString(HAConfiguration.ATLAS_SERVER_ADDRESS_PREFIX +"id1")).thenReturn(HOST_PORT); when(configuration.getString( HAConfiguration.ATLAS_SERVER_HA_ZK_ROOT_KEY, HAConfiguration.ATLAS_SERVER_ZK_ROOT_DEFAULT)). thenReturn(HAConfiguration.ATLAS_SERVER_ZK_ROOT_DEFAULT); when(curatorFactory.clientInstance()).thenReturn(curatorFramework); ExistsBuilder existsBuilder = mock(ExistsBuilder.class); when(curatorFramework.checkExists()).thenReturn(existsBuilder); when(existsBuilder.forPath(getPath())).thenReturn(null); CreateBuilder createBuilder = mock(CreateBuilder.class); when(curatorFramework.create()).thenReturn(createBuilder); when(createBuilder.withMode(CreateMode.EPHEMERAL)).thenReturn(createBuilder); when(createBuilder.withACL(ZooDefs.Ids.OPEN_ACL_UNSAFE)).thenReturn(createBuilder); SetDataBuilder setDataBuilder = mock(SetDataBuilder.class); when(curatorFramework.setData()).thenReturn(setDataBuilder); ActiveInstanceState activeInstanceState = new ActiveInstanceState(configuration, curatorFactory); activeInstanceState.update("id1"); verify(createBuilder).forPath(getPath()); }
parseAuth(String authString)	AtlasZookeeperSecurityProperties { public static AuthInfo parseAuth(String authString) { String[] authComponents = getComponents(authString, "authString", "scheme:authString"); return new AuthInfo(authComponents[0], authComponents[1].getBytes(Charsets.UTF_8)); } static ACL parseAcl(String aclString, ACL defaultAcl); static ACL parseAcl(String aclString); static AuthInfo parseAuth(String authString); }	@Test public void shouldGetAuth() { AuthInfo authInfo = AtlasZookeeperSecurityProperties.parseAuth("digest:user:password"); assertEquals(authInfo.getScheme(), "digest"); assertEquals(authInfo.getAuth(), "user:password".getBytes(Charsets.UTF_8)); }
createOrUpdate(EntityStream entityStream, boolean isPartialUpdate, boolean replaceClassifications)	AtlasEntityStoreV1 implements AtlasEntityStore { private EntityMutationResponse createOrUpdate(EntityStream entityStream, boolean isPartialUpdate, boolean replaceClassifications) throws AtlasBaseException { if (LOG.isDebugEnabled()) { LOG.debug("==> createOrUpdate()"); } if (entityStream == null \|\| !entityStream.hasNext()) { throw new AtlasBaseException(AtlasErrorCode.INVALID_PARAMETERS, "no entities to create/update."); } EntityMutationContext context = preCreateOrUpdate(entityStream, entityGraphMapper, isPartialUpdate); EntityMutationResponse ret = entityGraphMapper.mapAttributesAndClassifications(context, isPartialUpdate, replaceClassifications); ret.setGuidAssignments(context.getGuidAssignments()); if (LOG.isDebugEnabled()) { LOG.debug("<== createOrUpdate()"); } entityChangeNotifier.onEntitiesMutated(ret, entityStream instanceof EntityImportStream); return ret; } @Inject AtlasEntityStoreV1(DeleteHandlerV1 deleteHandler, AtlasTypeRegistry typeRegistry, AtlasEntityChangeNotifier entityChangeNotifier, EntityGraphMapper entityGraphMapper); @Override @GraphTransaction AtlasEntityWithExtInfo getById(String guid); @Override @GraphTransaction AtlasEntitiesWithExtInfo getByIds(List<String> guids); @Override @GraphTransaction AtlasEntityWithExtInfo getByUniqueAttributes(AtlasEntityType entityType, Map<String, Object> uniqAttributes); @Override @GraphTransaction EntityMutationResponse bulkImport(EntityImportStream entityStream, AtlasImportResult importResult); @Override @GraphTransaction EntityMutationResponse createOrUpdate(EntityStream entityStream, boolean isPartialUpdate); @Override @GraphTransaction EntityMutationResponse updateByUniqueAttributes(AtlasEntityType entityType, Map<String, Object> uniqAttributes, AtlasEntityWithExtInfo updatedEntityInfo); @Override @GraphTransaction EntityMutationResponse updateEntityAttributeByGuid(String guid, String attrName, Object attrValue); @Override @GraphTransaction EntityMutationResponse deleteById(final String guid); @Override @GraphTransaction EntityMutationResponse deleteByIds(final List<String> guids); @Override @GraphTransaction EntityMutationResponse deleteByUniqueAttributes(AtlasEntityType entityType, Map<String, Object> uniqAttributes); @Override @GraphTransaction void addClassifications(final String guid, final List<AtlasClassification> classifications); @Override @GraphTransaction void updateClassifications(String guid, List<AtlasClassification> newClassifications); @Override @GraphTransaction void addClassification(final List<String> guids, final AtlasClassification classification); @Override @GraphTransaction void deleteClassifications(final String guid, final List<String> classificationNames); @Override @GraphTransaction List<AtlasClassification> getClassifications(String guid); @Override @GraphTransaction AtlasClassification getClassification(String guid, String classificationName); }	@Test(dependsOnMethods = "testCreate") public void testArrayOfStructs() throws Exception { AtlasEntity tableEntity = new AtlasEntity(tblEntity.getEntity()); AtlasEntitiesWithExtInfo entitiesInfo = new AtlasEntitiesWithExtInfo(tableEntity); List<AtlasStruct> partitions = new ArrayList<AtlasStruct>(){{ add(new AtlasStruct(TestUtilsV2.PARTITION_STRUCT_TYPE, TestUtilsV2.NAME, "part1")); add(new AtlasStruct(TestUtilsV2.PARTITION_STRUCT_TYPE, TestUtilsV2.NAME, "part2")); }}; tableEntity.setAttribute("partitions", partitions); init(); EntityMutationResponse response = entityStore.createOrUpdate(new AtlasEntityStream(entitiesInfo), false); AtlasEntityHeader updatedTable = response.getFirstUpdatedEntityByTypeName(TABLE_TYPE); validateEntity(entitiesInfo, getEntityFromStore(updatedTable)); partitions.add(new AtlasStruct(TestUtils.PARTITION_STRUCT_TYPE, TestUtilsV2.NAME, "part3")); init(); response = entityStore.createOrUpdate(new AtlasEntityStream(entitiesInfo), false); updatedTable = response.getFirstUpdatedEntityByTypeName(TABLE_TYPE); validateEntity(entitiesInfo, getEntityFromStore(updatedTable)); init(); partitions.remove(1); response = entityStore.createOrUpdate(new AtlasEntityStream(entitiesInfo), false); updatedTable = response.getFirstUpdatedEntityByTypeName(TABLE_TYPE); validateEntity(entitiesInfo, getEntityFromStore(updatedTable)); init(); partitions.get(0).setAttribute(TestUtilsV2.NAME, "part4"); response = entityStore.createOrUpdate(new AtlasEntityStream(entitiesInfo), false); updatedTable = response.getFirstUpdatedEntityByTypeName(TABLE_TYPE); validateEntity(entitiesInfo, getEntityFromStore(updatedTable)); partitions.add(new AtlasStruct(TestUtils.PARTITION_STRUCT_TYPE, TestUtilsV2.NAME, "part4")); init(); response = entityStore.createOrUpdate(new AtlasEntityStream(entitiesInfo), false); updatedTable = response.getFirstUpdatedEntityByTypeName(TABLE_TYPE); validateEntity(entitiesInfo, getEntityFromStore(updatedTable)); partitions.clear(); init(); response = entityStore.createOrUpdate(new AtlasEntityStream(entitiesInfo), false); updatedTable = response.getFirstUpdatedEntityByTypeName(TABLE_TYPE); validateEntity(entitiesInfo, getEntityFromStore(updatedTable)); }
isValidValue(Object obj)	AtlasClassificationType extends AtlasStructType { @Override public boolean isValidValue(Object obj) { if (obj != null) { for (AtlasClassificationType superType : superTypes) { if (!superType.isValidValue(obj)) { return false; } } return super.isValidValue(obj); } return true; } AtlasClassificationType(AtlasClassificationDef classificationDef); AtlasClassificationType(AtlasClassificationDef classificationDef, AtlasTypeRegistry typeRegistry); AtlasClassificationDef getClassificationDef(); @Override void resolveReferences(AtlasTypeRegistry typeRegistry); @Override void resolveReferencesPhase2(AtlasTypeRegistry typeRegistry); @Override void resolveReferencesPhase3(AtlasTypeRegistry typeRegistry); Set<String> getSuperTypes(); Set<String> getAllSuperTypes(); Set<String> getAllSubTypes(); Set<String> getTypeAndAllSubTypes(); String getTypeAndAllSubTypesQryStr(); boolean isSuperTypeOf(AtlasClassificationType classificationType); boolean isSuperTypeOf(String classificationName); boolean isSubTypeOf(AtlasClassificationType classificationType); boolean isSubTypeOf(String classificationName); @Override AtlasClassification createDefaultValue(); @Override boolean isValidValue(Object obj); @Override boolean isValidValueForUpdate(Object obj); @Override Object getNormalizedValue(Object obj); @Override Object getNormalizedValueForUpdate(Object obj); @Override boolean validateValue(Object obj, String objName, List<String> messages); @Override boolean validateValueForUpdate(Object obj, String objName, List<String> messages); void normalizeAttributeValues(AtlasClassification classification); void normalizeAttributeValuesForUpdate(AtlasClassification classification); @Override void normalizeAttributeValues(Map<String, Object> obj); void normalizeAttributeValuesForUpdate(Map<String, Object> obj); void populateDefaultValues(AtlasClassification classification); }	@Test public void testClassificationTypeIsValidValue() { for (Object value : validValues) { assertTrue(classificationType.isValidValue(value), "value=" + value); } for (Object value : invalidValues) { assertFalse(classificationType.isValidValue(value), "value=" + value); } }
isValidValue(Object obj)	AtlasEntityType extends AtlasStructType { @Override public boolean isValidValue(Object obj) { if (obj != null) { for (AtlasEntityType superType : superTypes) { if (!superType.isValidValue(obj)) { return false; } } return super.isValidValue(obj); } return true; } AtlasEntityType(AtlasEntityDef entityDef); AtlasEntityType(AtlasEntityDef entityDef, AtlasTypeRegistry typeRegistry); AtlasEntityDef getEntityDef(); @Override void resolveReferences(AtlasTypeRegistry typeRegistry); @Override void resolveReferencesPhase2(AtlasTypeRegistry typeRegistry); @Override void resolveReferencesPhase3(AtlasTypeRegistry typeRegistry); Set<String> getSuperTypes(); Set<String> getAllSuperTypes(); Set<String> getAllSubTypes(); Set<String> getTypeAndAllSubTypes(); Set<String> getTypeAndAllSuperTypes(); boolean isSuperTypeOf(AtlasEntityType entityType); boolean isSuperTypeOf(String entityTypeName); boolean isTypeOrSuperTypeOf(String entityTypeName); boolean isSubTypeOf(AtlasEntityType entityType); boolean isSubTypeOf(String entityTypeName); Map<String, AtlasAttribute> getRelationshipAttributes(); AtlasAttribute getRelationshipAttribute(String attributeName); List<AtlasRelationshipType> getRelationshipAttributeType(String attributeName); Map<String, List<AtlasRelationshipType>> getRelationshipAttributesType(); String getTypeAndAllSubTypesQryStr(); boolean hasRelationshipAttribute(String attributeName); String getQualifiedAttributeName(String attrName); @Override AtlasEntity createDefaultValue(); @Override AtlasEntity createDefaultValue(Object defaultValue); @Override boolean isValidValue(Object obj); @Override boolean isValidValueForUpdate(Object obj); @Override Object getNormalizedValue(Object obj); @Override Object getNormalizedValueForUpdate(Object obj); @Override AtlasAttribute getAttribute(String attributeName); @Override boolean validateValue(Object obj, String objName, List<String> messages); @Override boolean validateValueForUpdate(Object obj, String objName, List<String> messages); @Override AtlasType getTypeForAttribute(); void normalizeAttributeValues(AtlasEntity ent); void normalizeAttributeValuesForUpdate(AtlasEntity ent); @Override void normalizeAttributeValues(Map<String, Object> obj); void normalizeAttributeValuesForUpdate(Map<String, Object> obj); void populateDefaultValues(AtlasEntity ent); }	@Test public void testEntityTypeIsValidValue() { for (Object value : validValues) { assertTrue(entityType.isValidValue(value), "value=" + value); } for (Object value : invalidValues) { assertFalse(entityType.isValidValue(value), "value=" + value); } }
doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)	ActiveServerFilter implements Filter { @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { if (isFilteredURI(servletRequest)) { LOG.debug("Is a filtered URI: {}. Passing request downstream.", ((HttpServletRequest)servletRequest).getRequestURI()); filterChain.doFilter(servletRequest, servletResponse); } else if (isInstanceActive()) { LOG.debug("Active. Passing request downstream"); filterChain.doFilter(servletRequest, servletResponse); } else if (serviceState.isInstanceInTransition()) { HttpServletResponse httpServletResponse = (HttpServletResponse) servletResponse; LOG.error("Instance in transition. Service may not be ready to return a result"); httpServletResponse.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE); } else { HttpServletResponse httpServletResponse = (HttpServletResponse) servletResponse; String activeServerAddress = activeInstanceState.getActiveServerAddress(); if (activeServerAddress == null) { LOG.error("Could not retrieve active server address as it is null. Cannot redirect request {}", ((HttpServletRequest)servletRequest).getRequestURI()); httpServletResponse.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE); } else { handleRedirect((HttpServletRequest) servletRequest, httpServletResponse, activeServerAddress); } } } @Inject ActiveServerFilter(ActiveInstanceState activeInstanceState, ServiceState serviceState); @Override void init(FilterConfig filterConfig); @Override void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain); @Override void destroy(); }	@Test public void testShouldNotRedirectAdminAPIs() throws IOException, ServletException { when(serviceState.getState()).thenReturn(ServiceState.ServiceStateValue.PASSIVE); when(servletRequest.getMethod()).thenReturn(HttpMethod.GET); when(servletRequest.getRequestURI()). thenReturn("api/atlas/admin/asmasn"); ActiveServerFilter activeServerFilter = new ActiveServerFilter(activeInstanceState, serviceState); activeServerFilter.doFilter(servletRequest, servletResponse, filterChain); verify(filterChain).doFilter(servletRequest, servletResponse); verifyZeroInteractions(activeInstanceState); }
stop()	ActiveInstanceElectorService implements Service, LeaderLatchListener { @Override public void stop() { if (!HAConfiguration.isHAEnabled(configuration)) { LOG.info("HA is not enabled, no need to stop leader election service"); return; } try { leaderLatch.close(); curatorFactory.close(); } catch (IOException e) { LOG.error("Error closing leader latch", e); } } @Inject ActiveInstanceElectorService(Configuration configuration, Set<ActiveStateChangeHandler> activeStateChangeHandlerProviders, CuratorFactory curatorFactory, ActiveInstanceState activeInstanceState, ServiceState serviceState); @Override void start(); @Override void stop(); @Override void isLeader(); @Override void notLeader(); }	@Test public void testNoActionOnStopIfHAModeIsDisabled() { when(configuration.getBoolean(HAConfiguration.ATLAS_SERVER_HA_ENABLED_KEY, false)).thenReturn(false); ActiveInstanceElectorService activeInstanceElectorService = new ActiveInstanceElectorService(configuration, new HashSet<ActiveStateChangeHandler>(), curatorFactory, activeInstanceState, serviceState); activeInstanceElectorService.stop(); verifyZeroInteractions(curatorFactory); }
parseAcl(String aclString, ACL defaultAcl)	AtlasZookeeperSecurityProperties { public static ACL parseAcl(String aclString, ACL defaultAcl) { if (StringUtils.isEmpty(aclString)) { return defaultAcl; } return parseAcl(aclString); } static ACL parseAcl(String aclString, ACL defaultAcl); static ACL parseAcl(String aclString); static AuthInfo parseAuth(String authString); }	@Test public void idsWithColonsAreValid() { ACL acl = AtlasZookeeperSecurityProperties.parseAcl("auth:user:password"); assertEquals(acl.getId().getScheme(), "auth"); assertEquals(acl.getId().getId(), "user:password"); }