package org.apache.usergrid.corepersistence.util;
/*
* 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.
*/
import java.util.UUID;
import org.apache.usergrid.persistence.core.scope.ApplicationScope;
import org.apache.usergrid.persistence.core.scope.ApplicationScopeImpl;
import org.apache.usergrid.persistence.entities.Application;
import org.apache.usergrid.persistence.entities.Group;
import org.apache.usergrid.persistence.graph.Edge;
import org.apache.usergrid.persistence.graph.SearchByEdge;
import org.apache.usergrid.persistence.graph.SearchByEdgeType;
import org.apache.usergrid.persistence.graph.SearchEdgeType;
import org.apache.usergrid.persistence.graph.impl.SimpleEdge;
import org.apache.usergrid.persistence.graph.impl.SimpleSearchByEdge;
import org.apache.usergrid.persistence.graph.impl.SimpleSearchEdgeType;
import org.apache.usergrid.persistence.index.IndexEdge;
import org.apache.usergrid.persistence.index.SearchEdge;
import org.apache.usergrid.persistence.index.impl.IndexEdgeImpl;
import org.apache.usergrid.persistence.index.impl.SearchEdgeImpl;
import org.apache.usergrid.persistence.map.MapScope;
import org.apache.usergrid.persistence.map.impl.MapScopeImpl;
import org.apache.usergrid.persistence.model.entity.Id;
import org.apache.usergrid.persistence.model.entity.SimpleId;
import org.apache.usergrid.persistence.model.util.UUIDGenerator;
import com.google.common.base.Optional;
/**
* Utilises for constructing standard naming conventions for collections and connections
*/
public class CpNamingUtils {
/** Edge types for collection suffix */
public static final String EDGE_COLL_PREFIX = "zzzcollzzz";
/**
* The length used when we trim a string
*/
private static final int EDGE_COLL_PREFIX_LENGTH = EDGE_COLL_PREFIX.length() + 1;
/** Edge types for connection suffix */
public static final String EDGE_CONN_PREFIX = "zzzconnzzz";
/**
* The length used when we trim a string on edge names
*/
private static final int EDGE_CONN_PREFIX_LENGTH = EDGE_CONN_PREFIX.length()+1;
/** App where we store management info */
public static final UUID MANAGEMENT_APPLICATION_ID = UUID.fromString( "b6768a08-b5d5-11e3-a495-11ddb1de66c8" );
/**
* Information about applications is stored in the management app using these types
*/
public static final String APPLICATION_INFO = "org_application";
public static final String APPLICATION_INFOS = "org_applications";
public static final String DELETED_APPLICATION_INFO = "deleted_org_application";
public static final String DELETED_APPLICATION_INFOS = "deleted_org_applications";
public static final String ORG_CONFIG = "org_config";
public static final String ORG_CONFIGS = "org_configs";
/**
* The name of the map that holds our entity id->type mapping
*/
public static String TYPES_BY_UUID_MAP = "zzz_typesbyuuid_zzz";
/**
* Generate a standard edge name for our graph using the connection name. To be used only for searching. DO NOT use
* for creation. Use the createConnectionEdge instead.
*
* @param connectionType The type of connection made
*/
public static String getEdgeTypeFromConnectionType( String connectionType ) {
return ( EDGE_CONN_PREFIX + "|" + connectionType ).toLowerCase();
}
/**
* Get the name of the collection from the edge name
* @param edgeName
* @return
*/
public static String getConnectionNameFromEdgeName(final String edgeName){
return edgeName.substring( EDGE_CONN_PREFIX_LENGTH );
}
/**
* Generate a standard edges from for a collection
*
* To be used only for searching DO NOT use for creation. Use the createCollectionEdge instead.
*/
public static String getEdgeTypeFromCollectionName( String collectionName ) {
return ((collectionName.startsWith(EDGE_COLL_PREFIX) ? collectionName : EDGE_COLL_PREFIX + "|" + collectionName) ).toLowerCase();
}
/**
* Get the name of the collection from the edge name
* @param edgeName
* @return
*/
public static String getCollectionNameFromEdgeName(final String edgeName){
return edgeName.substring( EDGE_COLL_PREFIX_LENGTH );
}
/**
* Get the index scope for the edge from the source to the target. The entity being indexed
* is the target node
*/
public static IndexEdge generateScopeFromSource( final Edge edge ) {
return new IndexEdgeImpl( edge.getSourceNode(), edge.getType(), SearchEdge.NodeType.TARGET,
edge.getTimestamp() );
}
/**
* Get the index scope for the edge from the source. The entity being indexed is the source node
*/
public static IndexEdge generateScopeFromTarget( final Edge edge ) {
return new IndexEdgeImpl( edge.getTargetNode(), edge.getType(), SearchEdge.NodeType.SOURCE,
edge.getTimestamp() );
}
/**
* Create the search edge from the source. The nodes being searched are Target nodes on the edges
*/
public static SearchEdge createSearchEdgeFromSource( final Edge edge ) {
return new SearchEdgeImpl( edge.getSourceNode(), edge.getType(), SearchEdge.NodeType.TARGET );
}
/**
* Create the search edge from the target. The nodes being searched are source nodes on the edges
*/
public static SearchEdge createSearchEdgeFromTarget( final Edge edge ) {
return new SearchEdgeImpl( edge.getTargetNode(), edge.getType(), SearchEdge.NodeType.SOURCE );
}
public static SearchByEdge createEdgeFromCollectionName(Id source, String connectionName, Id target) {
final String edgeType = CpNamingUtils.getEdgeTypeFromCollectionName(connectionName);
return new SimpleSearchByEdge(source, edgeType, target, Long.MAX_VALUE, SearchByEdgeType.Order.DESCENDING, Optional.<Edge>absent());
}
public static SearchByEdge createEdgeFromConnectionType(Id source, String connectionType, Id target) {
final String edgeType = CpNamingUtils.getEdgeTypeFromConnectionType(connectionType);
return new SimpleSearchByEdge(source, edgeType, target, Long.MAX_VALUE, SearchByEdgeType.Order.DESCENDING, Optional.<Edge>absent());
}
/**
* TODO move sourceId to ApplicationScope
*/
public static Edge createCollectionEdge( final Id sourceId, final String collectionName, final Id entityId ) {
final String edgeType = CpNamingUtils.getEdgeTypeFromCollectionName( collectionName );
// create graph edge connection from head entity to member entity
return new SimpleEdge( sourceId, edgeType, entityId, createGraphOperationTimestamp() );
}
/**
* Create a connection searchEdge
*/
public static SearchEdge createCollectionSearchEdge( final Id sourceId, final String connectionType ) {
return new SearchEdgeImpl( sourceId, getEdgeTypeFromCollectionName( connectionType ),
SearchEdge.NodeType.TARGET );
}
/**
* Create a new connection edge from the source node with the given connection type and target id
*/
public static Edge createConnectionEdge( final Id sourceEntityId, final String connectionType,
final Id targetEntityId ) {
final String edgeType = getEdgeTypeFromConnectionType( connectionType );
// create graph edge connection from head entity to member entity
return new SimpleEdge( sourceEntityId, edgeType, targetEntityId, createGraphOperationTimestamp() );
}
/**
* When marking nodes for deletion we must use the same unit of measure as the edge timestamps
* @return
*/
public static long createGraphOperationTimestamp(){
return UUIDGenerator.newTimeUUID().timestamp();
}
/**
* Create a connection searchEdge
*
* @param sourceId The source id in the connection
* @param connectionType The type of the connection to create a search for
*/
public static SearchEdge createConnectionSearchEdge( final Id sourceId, final String connectionType ) {
return new SearchEdgeImpl( sourceId, getEdgeTypeFromConnectionType( connectionType ),
SearchEdge.NodeType.TARGET );
}
/**
* search for all versions of a connection between 2 entities in teh graph
*
* @param sourceId The source id of the edge
* @param connectionType The connection type used in the edge
* @param targetId The target id
*
* @return A search by edge command to search the graph
*/
public static SearchByEdge createConnectionSearchByEdge( final Id sourceId, final String connectionType,
final Id targetId ) {
final String edgeType = getEdgeTypeFromConnectionType( connectionType );
return new SimpleSearchByEdge( sourceId, edgeType, targetId, Long.MAX_VALUE, SearchByEdgeType.Order.DESCENDING,
Optional.absent() );
}
/**
* Create a search edge based on the type
*
* @param sourceId The id in the search
*/
public static SearchEdgeType createConnectionTypeSearch( final Id sourceId ) {
return new SimpleSearchEdgeType( sourceId, EDGE_CONN_PREFIX, null );
}
/**
* Get the application scope from the given uuid
*
* @param applicationId The applicationId
*/
public static ApplicationScope getApplicationScope( UUID applicationId ) {
// We can always generate a scope, it doesn't matter if the application exists yet or not.
return new ApplicationScopeImpl( generateApplicationId( applicationId ) );
}
/**
* Generate an entity Id from the given UUID
*
* @param entityId the entity's UUID
*/
public static Id generateEntityId( UUID entityId, String entityType ) {
return new SimpleId( entityId, entityType );
}
/**
* Generate an applicationId from the given UUID
*
* @param applicationId the applicationId
*/
public static Id generateApplicationId( UUID applicationId ) {
return generateEntityId( applicationId, Application.ENTITY_TYPE );
}
/**
* Generate an organizationId from the given UUID
*
* @param organizationId the organizationId
*/
public static Id generateOrganizationId( UUID organizationId ) {
return generateEntityId( organizationId, Group.ENTITY_TYPE );
}
/**
* Generate an application scope for the management application
*/
public static Id getManagementApplicationId() {
return generateApplicationId( MANAGEMENT_APPLICATION_ID );
}
/**
* Get the map scope for the applicationId to store entity uuid to type mapping
*/
public static MapScope getEntityTypeMapScope( final Id applicationId ) {
return new MapScopeImpl( applicationId, CpNamingUtils.TYPES_BY_UUID_MAP );
}
/**
* Generate either the collection name or connection name from the edgeName
*/
public static String getNameFromEdgeType( final String edgeName ) {
if ( isCollectionEdgeType( edgeName ) ) {
return getCollectionName( edgeName ) ;
}
return getConnectionType( edgeName ) ;
}
private static boolean isCollectionEdgeType( String type ) {
return type.startsWith( EDGE_COLL_PREFIX );
}
private static String getConnectionType( String edgeType ) {
String[] parts = edgeType.split( "\\|" );
return parts[1];
}
private static String getCollectionName( String edgeType ) {
String[] parts = edgeType.split( "\\|" );
return parts[1];
}
}