Unnamed: 0
int64 0
6.7k
| func
stringlengths 12
89.6k
| target
bool 2
classes | project
stringlengths 45
151
|
|---|---|---|---|
5,600
|
{
@Override
public int read( ByteBuffer dst ) throws IOException
{
return 0;
}
@Override
public long read( ByteBuffer[] dsts, int offset, int length ) throws IOException
{
return 0;
}
@Override
public long position() throws IOException
{
return 0;
}
@Override
public StoreChannel position( long newPosition ) throws IOException
{
if ( newPosition != 0 )
throw unsupported();
return this;
}
@Override
public long size() throws IOException
{
return 0;
}
@Override
public StoreChannel truncate( long size ) throws IOException
{
if ( size != 0 )
throw unsupported();
return this;
}
@Override
public void force( boolean metaData ) throws IOException
{
}
@Override
public int read( ByteBuffer dst, long position ) throws IOException
{
return 0;
}
@Override
public int write( ByteBuffer src, long position ) throws IOException
{
if ( position != 0 )
throw unsupported();
return 0;
}
@Override
public void close() throws IOException
{
onClose.run();
}
private IOException unsupported()
{
return new IOException( "Unsupported" );
}
};
| false
|
community_kernel_src_test_java_org_neo4j_kernel_CannedFileSystemAbstraction.java
|
5,601
|
public class DummyExtension implements Lifecycle
{
LifecycleStatus status = LifecycleStatus.NONE;
private DummyExtensionFactory.Dependencies dependencies;
public DummyExtension( DummyExtensionFactory.Dependencies dependencies )
{
this.dependencies = dependencies;
}
@Override
public void init() throws Throwable
{
if ( status != LifecycleStatus.NONE )
{
throw new IllegalStateException( "Wrong state:" + status );
}
status = LifecycleStatus.STOPPED;
}
@Override
public void start() throws Throwable
{
if ( status != LifecycleStatus.STOPPED )
{
throw new IllegalStateException( "Wrong state:" + status );
}
status = LifecycleStatus.STARTED;
}
@Override
public void stop() throws Throwable
{
if ( status != LifecycleStatus.STARTED )
{
throw new IllegalStateException( "Wrong state:" + status );
}
status = LifecycleStatus.STOPPED;
}
@Override
public void shutdown() throws Throwable
{
if ( status != LifecycleStatus.STOPPED )
{
throw new IllegalStateException( "Wrong state:" + status );
}
status = LifecycleStatus.SHUTDOWN;
}
public LifecycleStatus getStatus()
{
return status;
}
public DummyExtensionFactory.Dependencies getDependencies()
{
return dependencies;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_DummyExtension.java
|
5,602
|
@Deprecated
public class EmbeddedGraphDatabase extends InternalAbstractGraphDatabase
{
/**
* Internal constructor used by {@link org.neo4j.graphdb.factory.GraphDatabaseFactory}
*/
public EmbeddedGraphDatabase( String storeDir,
Map<String, String> params,
Dependencies dependencies )
{
super( storeDir, params, dependencies );
run();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_EmbeddedGraphDatabase.java
|
5,603
|
{
@Override
public Node getNodeByIdOrNull( final long nodeId )
{
guard.check();
return super.getNodeByIdOrNull( nodeId );
}
@Override
public NodeImpl getNodeForProxy( final long nodeId, final LockType lock )
{
guard.check();
return super.getNodeForProxy( nodeId, lock );
}
@Override
public RelationshipImpl getRelationshipForProxy( final long relId )
{
guard.check();
return super.getRelationshipForProxy( relId );
}
@Override
protected Relationship getRelationshipByIdOrNull( final long relId )
{
guard.check();
return super.getRelationshipByIdOrNull( relId );
}
@Override
public Node createNode()
{
guard.check();
return super.createNode();
}
@Override
public Relationship createRelationship( Node startNodeProxy, NodeImpl startNode,
Node endNode, long relationshipTypeId )
{
guard.check();
return super.createRelationship( startNodeProxy, startNode, endNode, relationshipTypeId );
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_InternalAbstractGraphDatabase.java
|
5,604
|
@Deprecated
public final class EmbeddedReadOnlyGraphDatabase extends InternalAbstractGraphDatabase
{
private static Map<String, String> readOnlyParams = new HashMap<>();
static
{
readOnlyParams.put( GraphDatabaseSettings.read_only.name(), Settings.TRUE );
}
public EmbeddedReadOnlyGraphDatabase( String storeDir,
Map<String, String> params,
Dependencies dependencies )
{
super( storeDir, addReadOnly( params ), dependencies );
run();
}
private static Map<String, String> addReadOnly( Map<String, String> params )
{
params.putAll( readOnlyParams );
return params;
}
@Override
public KernelEventHandler registerKernelEventHandler(
KernelEventHandler handler )
{
throw new UnsupportedOperationException();
}
@Override
public <T> TransactionEventHandler<T> registerTransactionEventHandler(
TransactionEventHandler<T> handler )
{
throw new UnsupportedOperationException();
}
@Override
public KernelEventHandler unregisterKernelEventHandler(
KernelEventHandler handler )
{
throw new UnsupportedOperationException();
}
@Override
public <T> TransactionEventHandler<T> unregisterTransactionEventHandler(
TransactionEventHandler<T> handler )
{
throw new UnsupportedOperationException();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_EmbeddedReadOnlyGraphDatabase.java
|
5,605
|
{
@Override
public Node getNodeByIdOrNull( final long nodeId )
{
guard.check();
return super.getNodeByIdOrNull( nodeId );
}
@Override
public NodeImpl getNodeForProxy( final long nodeId, final LockType lock )
{
guard.check();
return super.getNodeForProxy( nodeId, lock );
}
@Override
public RelationshipImpl getRelationshipForProxy( final long relId )
{
guard.check();
return super.getRelationshipForProxy( relId );
}
@Override
protected Relationship getRelationshipByIdOrNull( final long relId )
{
guard.check();
return super.getRelationshipByIdOrNull( relId );
}
@Override
public Node createNode()
{
guard.check();
return super.createNode();
}
@Override
public Relationship createRelationship( Node startNodeProxy, NodeImpl startNode,
Node endNode, long relationshipTypeId )
{
guard.check();
return super.createRelationship( startNodeProxy, startNode, endNode, relationshipTypeId );
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_InternalAbstractGraphDatabase.java
|
5,606
|
{
@Override
public byte[] newInstance()
{
return getNewGlobalId( DEFAULT_SEED, MASTER_ID_REPRESENTING_NO_MASTER );
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_InternalAbstractGraphDatabase.java
|
5,607
|
{
@Override
public void available()
{
msgLog.info( "Database is now ready" );
}
@Override
public void unavailable()
{
msgLog.info( "Database is now unavailable" );
}
} );
| false
|
community_kernel_src_main_java_org_neo4j_kernel_InternalAbstractGraphDatabase.java
|
5,608
|
{
@Override
public void notifyStatusChanged( Object instance, LifecycleStatus from, LifecycleStatus to )
{
// TODO do not explicitly depend on order of start() calls in txManager and XaDatasourceManager
// use two booleans instead
if ( instance instanceof KernelExtensions && to.equals( LifecycleStatus.STARTED ) )
{
InternalAbstractGraphDatabase.this.doAfterRecoveryAndStartup( true );
}
}
} );
| false
|
community_kernel_src_main_java_org_neo4j_kernel_InternalAbstractGraphDatabase.java
|
5,609
|
@Deprecated
public abstract class InternalAbstractGraphDatabase
extends AbstractGraphDatabase implements GraphDatabaseService, GraphDatabaseAPI, SchemaWriteGuard
{
public interface Dependencies
{
/**
* Allowed to be null. Null means that no external {@link Logging} was created, let the
* database create its own logging.
* @return
*/
Logging logging();
Iterable<Class<?>> settingsClasses();
Iterable<KernelExtensionFactory<?>> kernelExtensions();
Iterable<CacheProvider> cacheProviders();
Iterable<TransactionInterceptorProvider> transactionInterceptorProviders();
}
public static class Configuration
{
public static final Setting<Boolean> read_only = GraphDatabaseSettings.read_only;
public static final Setting<Boolean> use_memory_mapped_buffers =
GraphDatabaseSettings.use_memory_mapped_buffers;
public static final Setting<Boolean> execution_guard_enabled = GraphDatabaseSettings.execution_guard_enabled;
public static final Setting<String> cache_type = GraphDatabaseSettings.cache_type;
public static final Setting<Boolean> ephemeral = setting( "ephemeral", Settings.BOOLEAN, Settings.FALSE );
public static final Setting<File> store_dir = GraphDatabaseSettings.store_dir;
public static final Setting<File> neo_store = GraphDatabaseSettings.neo_store;
public static final Setting<File> logical_log = GraphDatabaseSettings.logical_log;
}
private static final long MAX_NODE_ID = IdType.NODE.getMaxValue();
private static final long MAX_RELATIONSHIP_ID = IdType.RELATIONSHIP.getMaxValue();
protected File storeDir;
protected Map<String, String> params;
protected final TransactionInterceptorProviders transactionInterceptorProviders;
protected StoreId storeId;
private final TransactionBuilder defaultTxBuilder = new TransactionBuilderImpl( this, ForceMode.forced );
protected final KernelExtensions kernelExtensions;
protected Config config;
protected DependencyResolver dependencyResolver;
protected Logging logging;
protected StringLogger msgLog;
protected StoreLockerLifecycleAdapter storeLocker;
protected KernelEventHandlers kernelEventHandlers;
protected TransactionEventHandlers transactionEventHandlers;
protected RelationshipTypeTokenHolder relationshipTypeTokenHolder;
protected NodeManager nodeManager;
protected IndexManagerImpl indexManager;
protected Schema schema;
protected KernelPanicEventGenerator kernelPanicEventGenerator;
protected KernelHealth kernelHealth;
protected RemoteTxHook txHook;
protected FileSystemAbstraction fileSystem;
protected XaDataSourceManager xaDataSourceManager;
protected LockManager lockManager;
protected IdGeneratorFactory idGeneratorFactory;
protected NioNeoDbPersistenceSource persistenceSource;
protected TxEventSyncHookFactory syncHook;
protected PersistenceManager persistenceManager;
protected PropertyKeyTokenHolder propertyKeyTokenHolder;
protected LabelTokenHolder labelTokenHolder;
protected IndexStore indexStore;
protected AbstractTransactionManager txManager;
protected TxIdGenerator txIdGenerator;
protected StoreFactory storeFactory;
protected XaFactory xaFactory;
protected DiagnosticsManager diagnosticsManager;
protected NeoStoreXaDataSource neoDataSource;
protected RecoveryVerifier recoveryVerifier;
protected Guard guard;
protected NodeAutoIndexerImpl nodeAutoIndexer;
protected RelationshipAutoIndexerImpl relAutoIndexer;
protected KernelData extensions;
protected Caches caches;
protected TransactionStateFactory stateFactory;
protected ThreadToStatementContextBridge statementContextProvider;
protected BridgingCacheAccess cacheBridge;
protected JobScheduler jobScheduler;
protected UpdateableSchemaState updateableSchemaState;
protected Monitors monitors;
protected final LifeSupport life = new LifeSupport();
private final Map<String, CacheProvider> cacheProviders;
protected AvailabilityGuard availabilityGuard;
protected long accessTimeout;
protected InternalAbstractGraphDatabase( String storeDir, Map<String, String> params, Dependencies dependencies )
{
this.params = params;
dependencyResolver = new DependencyResolverImpl();
// Setup configuration
params.put( Configuration.store_dir.name(), storeDir );
// SPI - provided services
this.cacheProviders = mapCacheProviders( dependencies.cacheProviders() );
config = new Config( params, getSettingsClasses(
dependencies.settingsClasses(), dependencies.kernelExtensions(), dependencies.cacheProviders() ) );
this.logging = dependencies.logging();
this.kernelExtensions = new KernelExtensions(
dependencies.kernelExtensions(),
config,
getDependencyResolver(),
UnsatisfiedDependencyStrategies.fail() );
this.transactionInterceptorProviders = new TransactionInterceptorProviders(
dependencies.transactionInterceptorProviders(),
dependencyResolver );
this.storeDir = config.get( Configuration.store_dir );
accessTimeout = 1 * 1000; // TODO make configurable
}
private Map<String, CacheProvider> mapCacheProviders( Iterable<CacheProvider> cacheProviders )
{
Map<String, CacheProvider> map = new HashMap<>();
for ( CacheProvider provider : cacheProviders )
{
map.put( provider.getName(), provider );
}
return map;
}
protected void run()
{
create();
try
{
registerRecovery();
life.start();
Throwable recoveryError = txManager.getRecoveryError();
if ( recoveryError != null )
{
throw recoveryError;
}
}
catch ( final Throwable throwable )
{
StringBuilder msg = new StringBuilder();
msg.append( "Startup failed" );
Throwable temporaryThrowable = throwable;
while ( temporaryThrowable != null )
{
msg.append( ": " ).append( temporaryThrowable.getMessage() );
temporaryThrowable = temporaryThrowable.getCause();
}
msgLog.error( msg.toString() );
shutdown();
throw new RuntimeException( "Error starting " + getClass().getName() + ", " + storeDir.getAbsolutePath(),
throwable );
}
}
protected void createDatabaseAvailability()
{
// This is how we lock the entire database to avoid threads using it during lifecycle events
life.add( new DatabaseAvailability( txManager, availabilityGuard ) );
}
protected void registerRecovery()
{
life.addLifecycleListener( new LifecycleListener()
{
@Override
public void notifyStatusChanged( Object instance, LifecycleStatus from, LifecycleStatus to )
{
// TODO do not explicitly depend on order of start() calls in txManager and XaDatasourceManager
// use two booleans instead
if ( instance instanceof KernelExtensions && to.equals( LifecycleStatus.STARTED ) )
{
InternalAbstractGraphDatabase.this.doAfterRecoveryAndStartup( true );
}
}
} );
}
protected void doAfterRecoveryAndStartup( boolean isMaster )
{
if ( txManager.getRecoveryError() != null )
{ // If recovery failed then there's no point in going any further here. The database startup will fail.
return;
}
if ( txManager instanceof TxManager )
{
@SuppressWarnings("deprecation")
NeoStoreXaDataSource neoStoreDataSource = xaDataSourceManager.getNeoStoreDataSource();
storeId = neoStoreDataSource.getStoreId();
KernelDiagnostics.register( diagnosticsManager, InternalAbstractGraphDatabase.this, neoStoreDataSource );
if ( isMaster )
{
new RemoveOrphanConstraintIndexesOnStartup( new Transactor( txManager, persistenceManager ), logging )
.perform();
}
}
}
protected void create()
{
availabilityGuard = createAvailabilityGuard();
availabilityGuard.addListener( new AvailabilityGuard.AvailabilityListener()
{
@Override
public void available()
{
msgLog.info( "Database is now ready" );
}
@Override
public void unavailable()
{
msgLog.info( "Database is now unavailable" );
}
} );
fileSystem = createFileSystemAbstraction();
// If no logging was passed in from the outside then create logging and register
// with this life
if ( this.logging == null )
{
this.logging = createLogging();
}
// Component monitoring
this.monitors = createMonitors();
// Apply autoconfiguration for memory settings
AutoConfigurator autoConfigurator = new AutoConfigurator( fileSystem,
config.get( NeoStoreXaDataSource.Configuration.store_dir ),
config.get( Configuration.use_memory_mapped_buffers ),
logging.getConsoleLog( AutoConfigurator.class ) );
if (config.get( GraphDatabaseSettings.dump_configuration ))
{
System.out.println( autoConfigurator.getNiceMemoryInformation() );
}
Map<String, String> configParams = config.getParams();
Map<String, String> autoConfiguration = autoConfigurator.configure();
for ( Map.Entry<String, String> autoConfig : autoConfiguration.entrySet() )
{
// Don't override explicit settings
String key = autoConfig.getKey();
if ( !params.containsKey( key ) )
{
configParams.put( key, autoConfig.getValue() );
}
}
config.applyChanges( configParams );
this.msgLog = logging.getMessagesLog( getClass() );
config.setLogger( msgLog );
this.storeLocker = life.add( new StoreLockerLifecycleAdapter(
new StoreLocker( fileSystem ), storeDir ) );
new JvmChecker( msgLog, new JvmMetadataRepository() ).checkJvmCompatibilityAndIssueWarning();
// Instantiate all services - some are overridable by subclasses
boolean readOnly = config.get( Configuration.read_only );
String cacheTypeName = config.get( Configuration.cache_type );
CacheProvider cacheProvider = cacheProviders.get( cacheTypeName );
if ( cacheProvider == null )
{
throw new IllegalArgumentException( "No provider for cache type '" + cacheTypeName + "'. " +
"Cache providers are loaded using java service loading where they " +
"register themselves in resource (plain-text) files found on the class path under " +
"META-INF/services/" + CacheProvider.class.getName() + ". This missing provider may have " +
"been caused by either such a missing registration, or by the lack of the provider class itself." );
}
jobScheduler =
life.add( new Neo4jJobScheduler( this.toString(), logging.getMessagesLog( Neo4jJobScheduler.class ) ));
kernelEventHandlers = new KernelEventHandlers(logging.getMessagesLog( KernelEventHandlers.class ));
caches = createCaches();
diagnosticsManager = life.add( new DiagnosticsManager( logging.getMessagesLog( DiagnosticsManager.class ) ) );
kernelPanicEventGenerator = new KernelPanicEventGenerator( kernelEventHandlers );
kernelHealth = new KernelHealth( kernelPanicEventGenerator, logging );
xaDataSourceManager = life.add( createXaDataSourceManager() );
txHook = createTxHook();
guard = config.get( Configuration.execution_guard_enabled ) ? new Guard( msgLog ) : null;
stateFactory = createTransactionStateFactory();
Factory<byte[]> xidGlobalIdFactory = createXidGlobalIdFactory();
updateableSchemaState = new KernelSchemaStateStore( newSchemaStateMap() );
if ( readOnly )
{
txManager = new ReadOnlyTxManager( xaDataSourceManager, xidGlobalIdFactory,
logging.getMessagesLog( ReadOnlyTxManager.class ) );
}
else
{
String serviceName = config.get( GraphDatabaseSettings.tx_manager_impl );
if ( GraphDatabaseSettings.tx_manager_impl.getDefaultValue().equals( serviceName ) )
{
txManager = new TxManager( this.storeDir, xaDataSourceManager,
logging.getMessagesLog( TxManager.class ), fileSystem, stateFactory,
xidGlobalIdFactory, kernelHealth, monitors );
}
else
{
TransactionManagerProvider provider;
provider = Service.load( TransactionManagerProvider.class, serviceName );
txManager = provider.loadTransactionManager( this.storeDir.getPath(), xaDataSourceManager,
kernelPanicEventGenerator, txHook, logging.getMessagesLog( AbstractTransactionManager.class ),
fileSystem, stateFactory );
}
}
life.add( txManager );
transactionEventHandlers = new TransactionEventHandlers( txManager );
txIdGenerator = life.add( createTxIdGenerator() );
lockManager = createLockManager();
idGeneratorFactory = createIdGeneratorFactory();
persistenceSource = life.add( new NioNeoDbPersistenceSource( xaDataSourceManager ) );
syncHook = new DefaultTxEventSyncHookFactory();
persistenceManager = new PersistenceManager( logging.getMessagesLog( PersistenceManager.class ), txManager,
persistenceSource, syncHook );
propertyKeyTokenHolder = life.add( new PropertyKeyTokenHolder( txManager, persistenceManager, persistenceSource, createPropertyKeyCreator() ) );
labelTokenHolder = life.add( new LabelTokenHolder( txManager, persistenceManager, persistenceSource, createLabelIdCreator() ) );
relationshipTypeTokenHolder = life.add( new RelationshipTypeTokenHolder( txManager,
persistenceManager, persistenceSource, createRelationshipTypeCreator() ) );
caches.configure( cacheProvider, config );
Cache<NodeImpl> nodeCache = diagnosticsManager.tryAppendProvider( caches.node() );
Cache<RelationshipImpl> relCache = diagnosticsManager.tryAppendProvider( caches.relationship() );
statementContextProvider = life.add( new ThreadToStatementContextBridge( persistenceManager ) );
nodeManager = guard != null ?
createGuardedNodeManager( readOnly, cacheProvider, nodeCache, relCache ) :
createNodeManager( readOnly, cacheProvider, nodeCache, relCache );
stateFactory.setDependencies( lockManager, nodeManager, txHook, txIdGenerator );
indexStore = life.add( new IndexStore( this.storeDir, fileSystem ) );
diagnosticsManager.prependProvider( config );
// Config can auto-configure memory mapping settings and what not, so reassign params
// after we've instantiated Config.
params = config.getParams();
extensions = life.add( createKernelData() );
life.add( kernelExtensions );
schema = new SchemaImpl( statementContextProvider );
indexManager = new IndexManagerImpl( config, indexStore, xaDataSourceManager, txManager, this );
nodeAutoIndexer = life.add( new NodeAutoIndexerImpl( config, indexManager, nodeManager ) );
relAutoIndexer = life.add( new RelationshipAutoIndexerImpl( config, indexManager, nodeManager ) );
// TODO This cyclic dependency should be resolved
indexManager.setNodeAutoIndexer( nodeAutoIndexer );
indexManager.setRelAutoIndexer( relAutoIndexer );
recoveryVerifier = createRecoveryVerifier();
// Factories for things that needs to be created later
storeFactory = createStoreFactory();
String keepLogicalLogsConfig = config.get( GraphDatabaseSettings.keep_logical_logs );
xaFactory = new XaFactory( config, txIdGenerator, txManager, fileSystem,
monitors, logging, recoveryVerifier, LogPruneStrategies.fromConfigValue(
fileSystem, keepLogicalLogsConfig ), kernelHealth );
createNeoDataSource();
life.add( new MonitorGc( config, msgLog ) );
life.add( nodeManager );
createDatabaseAvailability();
// Kernel event handlers should be the very last, i.e. very first to receive shutdown events
life.add( kernelEventHandlers );
// TODO This is probably too coarse-grained and we should have some strategy per user of config instead
life.add( new ConfigurationChangedRestarter() );
}
protected Monitors createMonitors()
{
return new Monitors();
}
protected Factory<byte[]> createXidGlobalIdFactory()
{
return new Factory<byte[]>()
{
@Override
public byte[] newInstance()
{
return getNewGlobalId( DEFAULT_SEED, MASTER_ID_REPRESENTING_NO_MASTER );
}
};
}
protected AvailabilityGuard createAvailabilityGuard()
{
return new AvailabilityGuard( Clock.SYSTEM_CLOCK, 1 );
}
@Override
public void assertSchemaWritesAllowed() throws InvalidTransactionTypeKernelException
{
}
private Map<Object, Object> newSchemaStateMap() {
return new HashMap<>();
}
protected TransactionStateFactory createTransactionStateFactory()
{
return new TransactionStateFactory( logging );
}
protected XaDataSourceManager createXaDataSourceManager()
{
return new XaDataSourceManager( logging.getMessagesLog( XaDataSourceManager.class ) );
}
@Override
public DependencyResolver getDependencyResolver()
{
return dependencyResolver;
}
protected TokenCreator createRelationshipTypeCreator()
{
return new DefaultRelationshipTypeCreator( logging );
}
protected TokenCreator createPropertyKeyCreator()
{
return new DefaultPropertyTokenCreator( logging );
}
protected TokenCreator createLabelIdCreator()
{
return new DefaultLabelIdCreator( logging );
}
private NodeManager createNodeManager( final boolean readOnly, final CacheProvider cacheType,
Cache<NodeImpl> nodeCache, Cache<RelationshipImpl> relCache )
{
if ( readOnly )
{
return new ReadOnlyNodeManager( logging.getMessagesLog( NodeManager.class ), this, txManager, persistenceManager,
persistenceSource, relationshipTypeTokenHolder, cacheType, propertyKeyTokenHolder, labelTokenHolder,
createNodeLookup(), createRelationshipLookups(), nodeCache, relCache, xaDataSourceManager,
statementContextProvider );
}
return new NodeManager(
logging.getMessagesLog( NodeManager.class ), this, txManager, persistenceManager,
persistenceSource, relationshipTypeTokenHolder, cacheType, propertyKeyTokenHolder, labelTokenHolder,
createNodeLookup(), createRelationshipLookups(), nodeCache, relCache, xaDataSourceManager,
statementContextProvider );
}
private NodeManager createGuardedNodeManager( final boolean readOnly, final CacheProvider cacheType,
Cache<NodeImpl> nodeCache, Cache<RelationshipImpl> relCache )
{
if ( readOnly )
{
return new ReadOnlyNodeManager( logging.getMessagesLog( NodeManager.class ), this, txManager, persistenceManager,
persistenceSource, relationshipTypeTokenHolder, cacheType, propertyKeyTokenHolder, labelTokenHolder, createNodeLookup(),
createRelationshipLookups(), nodeCache, relCache, xaDataSourceManager, statementContextProvider )
{
@Override
public Node getNodeByIdOrNull( final long nodeId )
{
guard.check();
return super.getNodeByIdOrNull( nodeId );
}
@Override
public NodeImpl getNodeForProxy( final long nodeId, final LockType lock )
{
guard.check();
return super.getNodeForProxy( nodeId, lock );
}
@Override
public RelationshipImpl getRelationshipForProxy( final long relId )
{
guard.check();
return super.getRelationshipForProxy( relId );
}
@Override
protected Relationship getRelationshipByIdOrNull( final long relId )
{
guard.check();
return super.getRelationshipByIdOrNull( relId );
}
@Override
public Node createNode()
{
guard.check();
return super.createNode();
}
@Override
public Relationship createRelationship( Node startNodeProxy, NodeImpl startNode,
Node endNode, long relationshipTypeId )
{
guard.check();
return super.createRelationship( startNodeProxy, startNode, endNode, relationshipTypeId );
}
};
}
return new NodeManager( logging.getMessagesLog( NodeManager.class ), this, txManager, persistenceManager,
persistenceSource, relationshipTypeTokenHolder, cacheType, propertyKeyTokenHolder, labelTokenHolder, createNodeLookup(),
createRelationshipLookups(), nodeCache, relCache, xaDataSourceManager, statementContextProvider )
{
@Override
public Node getNodeByIdOrNull( final long nodeId )
{
guard.check();
return super.getNodeByIdOrNull( nodeId );
}
@Override
public NodeImpl getNodeForProxy( final long nodeId, final LockType lock )
{
guard.check();
return super.getNodeForProxy( nodeId, lock );
}
@Override
public RelationshipImpl getRelationshipForProxy( final long relId )
{
guard.check();
return super.getRelationshipForProxy( relId );
}
@Override
protected Relationship getRelationshipByIdOrNull( final long relId )
{
guard.check();
return super.getRelationshipByIdOrNull( relId );
}
@Override
public Node createNode()
{
guard.check();
return super.createNode();
}
@Override
public Relationship createRelationship( Node startNodeProxy, NodeImpl startNode,
Node endNode, long relationshipTypeId )
{
guard.check();
return super.createRelationship( startNodeProxy, startNode, endNode, relationshipTypeId );
}
};
}
@Override
public boolean isAvailable( long timeout )
{
return availabilityGuard.isAvailable( timeout );
}
@Override
public void shutdown()
{
try
{
msgLog.info( "Shutdown started" );
msgLog.flush();
availabilityGuard.shutdown();
life.shutdown();
}
catch ( LifecycleException throwable )
{
msgLog.warn( "Shutdown failed", throwable );
throw throwable;
}
}
protected StoreFactory createStoreFactory()
{
return new StoreFactory( config, idGeneratorFactory, createWindowPoolFactory(), fileSystem,
logging.getMessagesLog( StoreFactory.class ), txHook );
}
protected DefaultWindowPoolFactory createWindowPoolFactory()
{
return new DefaultWindowPoolFactory();
}
protected RecoveryVerifier createRecoveryVerifier()
{
return RecoveryVerifier.ALWAYS_VALID;
}
protected KernelData createKernelData()
{
return new DefaultKernelData( config, this );
}
protected TxIdGenerator createTxIdGenerator()
{
return TxIdGenerator.DEFAULT;
}
protected Caches createCaches()
{
return new DefaultCaches( msgLog, monitors );
}
protected RelationshipProxy.RelationshipLookups createRelationshipLookups()
{
return new RelationshipProxy.RelationshipLookups()
{
@Override
public RelationshipImpl lookupRelationship( long relationshipId )
{
assertDatabaseRunning();
return nodeManager.getRelationshipForProxy( relationshipId );
}
@Override
public GraphDatabaseService getGraphDatabaseService()
{
return InternalAbstractGraphDatabase.this;
}
@Override
public NodeManager getNodeManager()
{
return nodeManager;
}
@Override
public Node newNodeProxy( long nodeId )
{
// only used by relationship already checked as valid in cache
return nodeManager.newNodeProxyById( nodeId );
}
};
}
protected NodeProxy.NodeLookup createNodeLookup()
{
return new NodeProxy.NodeLookup()
{
@Override
public NodeImpl lookup( long nodeId )
{
assertDatabaseRunning();
return nodeManager.getNodeForProxy( nodeId, null );
}
@Override
public NodeImpl lookup( long nodeId, LockType lock )
{
assertDatabaseRunning();
return nodeManager.getNodeForProxy( nodeId, lock );
}
@Override
public GraphDatabaseService getGraphDatabase()
{
// TODO This should be wrapped as well
return InternalAbstractGraphDatabase.this;
}
@Override
public NodeManager getNodeManager()
{
return nodeManager;
}
};
}
// This is here until we've moved all operations into the kernel, which handles this check on it's own.
private void assertDatabaseRunning()
{
if( life.isRunning() )
{
return;
}
throw new DatabaseShutdownException();
}
protected RemoteTxHook createTxHook()
{
return new DefaultTxHook();
}
protected FileSystemAbstraction createFileSystemAbstraction()
{
return new DefaultFileSystemAbstraction();
}
protected IdGeneratorFactory createIdGeneratorFactory()
{
return new DefaultIdGeneratorFactory();
}
protected LockManager createLockManager()
{
return new LockManagerImpl( new RagManager() );
}
protected Logging createLogging()
{
return life.add( DefaultLogging.createDefaultLogging( config ) );
}
protected void createNeoDataSource()
{
// Create DataSource
neoDataSource = new NeoStoreXaDataSource( config,
storeFactory, logging.getMessagesLog( NeoStoreXaDataSource.class ),
xaFactory, stateFactory, transactionInterceptorProviders, jobScheduler, logging,
updateableSchemaState, new NonTransactionalTokenNameLookup( labelTokenHolder, propertyKeyTokenHolder ),
dependencyResolver, txManager, propertyKeyTokenHolder, labelTokenHolder, relationshipTypeTokenHolder,
persistenceManager, lockManager, this, monitors.newMonitor( IndexingService.Monitor.class ) );
xaDataSourceManager.registerDataSource( neoDataSource );
}
@Override
public final String getStoreDir()
{
return storeDir.getPath();
}
@Override
public StoreId storeId()
{
return storeId;
}
@Override
public Transaction beginTx()
{
return tx().begin();
}
protected Transaction beginTx( ForceMode forceMode )
{
if ( !availabilityGuard.isAvailable( accessTimeout ) )
{
throw new TransactionFailureException( "Database is currently not available. "
+ availabilityGuard.describeWhoIsBlocking() );
}
try
{
if ( transactionRunning() )
{
return new PlaceboTransaction( persistenceManager, txManager, txManager.getTransactionState() );
}
txManager.begin( forceMode );
return new TopLevelTransaction( persistenceManager, txManager, txManager.getTransactionState() );
}
catch ( SystemException e )
{
throw new TransactionFailureException( "Couldn't get transaction", e );
}
catch ( NotSupportedException e )
{
throw new TransactionFailureException( "Couldn't begin transaction", e );
}
}
@Override
public boolean transactionRunning()
{
try
{
return txManager.getTransaction() != null;
}
catch ( SystemException e )
{
throw new TransactionFailureException(
"Unable to get transaction.", e );
}
}
@Override
public String toString()
{
return getClass().getSimpleName() + " [" + getStoreDir() + "]";
}
@Override
public Iterable<Node> getAllNodes()
{
return GlobalGraphOperations.at( this ).getAllNodes();
}
@Override
public Iterable<RelationshipType> getRelationshipTypes()
{
return GlobalGraphOperations.at( this ).getAllRelationshipTypes();
}
@Override
public KernelEventHandler registerKernelEventHandler(
KernelEventHandler handler )
{
return kernelEventHandlers.registerKernelEventHandler( handler );
}
@Override
public <T> TransactionEventHandler<T> registerTransactionEventHandler(
TransactionEventHandler<T> handler )
{
return transactionEventHandlers.registerTransactionEventHandler( handler );
}
@Override
public KernelEventHandler unregisterKernelEventHandler(
KernelEventHandler handler )
{
return kernelEventHandlers.unregisterKernelEventHandler( handler );
}
@Override
public <T> TransactionEventHandler<T> unregisterTransactionEventHandler(
TransactionEventHandler<T> handler )
{
return transactionEventHandlers.unregisterTransactionEventHandler( handler );
}
@Override
public Node createNode()
{
try ( Statement statement = statementContextProvider.instance() )
{
return nodeManager.newNodeProxyById( statement.dataWriteOperations().nodeCreate() );
}
catch ( InvalidTransactionTypeKernelException e )
{
throw new ConstraintViolationException( e.getMessage(), e );
}
catch ( ReadOnlyDatabaseKernelException e )
{
throw new ReadOnlyDbException();
}
}
@Override
public Node createNode( Label... labels )
{
try ( Statement statement = statementContextProvider.instance() )
{
long nodeId = statement.dataWriteOperations().nodeCreate();
for ( Label label : labels )
{
int labelId = statement.tokenWriteOperations().labelGetOrCreateForName( label.name() );
try
{
statement.dataWriteOperations().nodeAddLabel( nodeId, labelId );
}
catch ( EntityNotFoundException e )
{
throw new NotFoundException( "No node with id " + nodeId + " found.", e );
}
}
return nodeManager.newNodeProxyById( nodeId );
}
catch ( ConstraintValidationKernelException e )
{
throw new ConstraintViolationException( "Unable to add label.", e );
}
catch ( SchemaKernelException e )
{
throw new IllegalArgumentException( e );
}
catch ( InvalidTransactionTypeKernelException e )
{
throw new ConstraintViolationException( e.getMessage(), e );
}
catch ( ReadOnlyDatabaseKernelException e )
{
throw new ReadOnlyDbException();
}
}
@Override
public Node getNodeById( long id )
{
if ( id < 0 || id > MAX_NODE_ID )
{
throw new NotFoundException( format( "Node %d not found", id ) );
}
return nodeManager.getNodeById( id );
}
@Override
public Relationship getRelationshipById( long id )
{
if ( id < 0 || id > MAX_RELATIONSHIP_ID )
{
throw new NotFoundException( format( "Relationship %d not found", id));
}
return nodeManager.getRelationshipById( id );
}
@Override
public TransactionBuilder tx()
{
return defaultTxBuilder;
}
@Override
public IndexManager index()
{
// TODO: txManager.assertInTransaction();
return indexManager;
}
@Override
public Schema schema()
{
txManager.assertInTransaction();
return schema;
}
// GraphDatabaseSPI implementation - THESE SHOULD EVENTUALLY BE REMOVED! DON'T ADD dependencies on these!
public Config getConfig()
{
return config;
}
private Iterable<Class<?>> getSettingsClasses( Iterable<Class<?>> settingsClasses,
Iterable<KernelExtensionFactory<?>> kernelExtensions,
Iterable<CacheProvider> cacheProviders )
{
List<Class<?>> totalSettingsClasses = new ArrayList<>();
// Add given settings classes
Iterables.addAll( totalSettingsClasses, settingsClasses );
// Get the list of settings classes for extensions
for ( KernelExtensionFactory<?> kernelExtension : kernelExtensions )
{
if ( kernelExtension.getSettingsClass() != null )
{
totalSettingsClasses.add( kernelExtension.getSettingsClass() );
}
}
for ( CacheProvider cacheProvider : cacheProviders )
{
if ( cacheProvider.getSettingsClass() != null )
{
totalSettingsClasses.add( cacheProvider.getSettingsClass() );
}
}
return totalSettingsClasses;
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || !(o instanceof InternalAbstractGraphDatabase) )
{
return false;
}
InternalAbstractGraphDatabase that = (InternalAbstractGraphDatabase) o;
return (storeId != null ? storeId.equals( that.storeId ) : that.storeId == null) &&
storeDir.equals( that.storeDir );
}
@Override
public int hashCode()
{
return storeDir.hashCode();
}
protected final class DefaultKernelData extends KernelData implements Lifecycle
{
private final GraphDatabaseAPI graphDb;
public DefaultKernelData( Config config, GraphDatabaseAPI graphDb )
{
super( config );
this.graphDb = graphDb;
}
@Override
public Version version()
{
return Version.getKernel();
}
@Override
public GraphDatabaseAPI graphDatabase()
{
return graphDb;
}
@Override
public void init() throws Throwable
{
}
@Override
public void start() throws Throwable
{
}
@Override
public void stop() throws Throwable
{
}
}
private class DefaultTxEventSyncHookFactory implements TxEventSyncHookFactory
{
@Override
public TransactionEventsSyncHook create()
{
return transactionEventHandlers.hasHandlers() ?
new TransactionEventsSyncHook( transactionEventHandlers, txManager ) : null;
}
}
/**
* FIXME: This is supposed to be handled by a Dependency Injection framework...
*
* @author ceefour
*/
class DependencyResolverImpl extends DependencyResolver.Adapter
{
private <T> T resolveKnownSingleDependency( Class<T> type )
{
if ( type.equals( Map.class ) )
{
return type.cast( getConfig().getParams() );
}
else if ( type.equals( Config.class ) )
{
return type.cast( getConfig() );
}
else if ( GraphDatabaseService.class.isAssignableFrom( type )
&& type.isInstance( InternalAbstractGraphDatabase.this ) )
{
return type.cast( InternalAbstractGraphDatabase.this );
}
else if ( TransactionManager.class.isAssignableFrom( type ) && type.isInstance( txManager ) )
{
return type.cast( txManager );
}
else if ( LockManager.class.isAssignableFrom( type ) && type.isInstance( lockManager ) )
{
// Locks used to ensure pessimistic concurrency control between transactions
return type.cast( lockManager );
}
else if ( LockService.class.isAssignableFrom( type )
&& type.isInstance( neoDataSource.getLockService() ) )
{
// Locks used to control concurrent access to the store files
return type.cast( neoDataSource.getLockService() );
}
else if( StoreFactory.class.isAssignableFrom( type ) && type.isInstance( storeFactory ) )
{
return type.cast( storeFactory );
}
else if ( StringLogger.class.isAssignableFrom( type ) && type.isInstance( msgLog ) )
{
return type.cast( msgLog );
}
else if ( Logging.class.isAssignableFrom( type ) && type.isInstance( logging ) )
{
return type.cast( logging );
}
else if ( IndexStore.class.isAssignableFrom( type ) && type.isInstance( indexStore ) )
{
return type.cast( indexStore );
}
else if ( XaFactory.class.isAssignableFrom( type ) && type.isInstance( xaFactory ) )
{
return type.cast( xaFactory );
}
else if ( XaDataSourceManager.class.isAssignableFrom( type ) && type.isInstance( xaDataSourceManager ) )
{
return type.cast( xaDataSourceManager );
}
else if ( FileSystemAbstraction.class.isAssignableFrom( type ) && type.isInstance( fileSystem ) )
{
return type.cast( fileSystem );
}
else if ( Guard.class.isAssignableFrom( type ) && type.isInstance( guard ) )
{
return type.cast( guard );
}
else if ( IndexProviders.class.isAssignableFrom( type ) && type.isInstance( indexManager ) )
{
return type.cast( indexManager );
}
else if ( KernelData.class.isAssignableFrom( type ) && type.isInstance( extensions ) )
{
return type.cast( extensions );
}
else if ( TransactionInterceptorProviders.class.isAssignableFrom( type )
&& type.isInstance( transactionInterceptorProviders ) )
{
return type.cast( transactionInterceptorProviders );
}
else if ( KernelExtensions.class.isAssignableFrom( type ) && type.isInstance( kernelExtensions ) )
{
return type.cast( kernelExtensions );
}
else if ( NodeManager.class.isAssignableFrom( type ) && type.isInstance( nodeManager ) )
{
return type.cast( nodeManager );
}
else if ( TransactionStateFactory.class.isAssignableFrom( type ) && type.isInstance( stateFactory ) )
{
return type.cast( stateFactory );
}
else if ( TxIdGenerator.class.isAssignableFrom( type ) && type.isInstance( txIdGenerator ) )
{
return type.cast( txIdGenerator );
}
else if ( DiagnosticsManager.class.isAssignableFrom( type ) && type.isInstance( diagnosticsManager ) )
{
return type.cast( diagnosticsManager );
}
else if ( RelationshipTypeTokenHolder.class.isAssignableFrom( type ) && type.isInstance( relationshipTypeTokenHolder ) )
{
return type.cast( relationshipTypeTokenHolder );
}
else if ( PropertyKeyTokenHolder.class.isAssignableFrom( type ) && type.isInstance( propertyKeyTokenHolder ) )
{
return type.cast( propertyKeyTokenHolder );
}
else if ( LabelTokenHolder.class.isAssignableFrom( type ) && type.isInstance( labelTokenHolder ) )
{
return type.cast( labelTokenHolder );
}
else if ( KernelPanicEventGenerator.class.isAssignableFrom( type ) )
{
return type.cast( kernelPanicEventGenerator );
}
else if ( LifeSupport.class.isAssignableFrom( type ) )
{
return type.cast( life );
}
else if ( Monitors.class.isAssignableFrom( type ) )
{
return type.cast( monitors );
}
else if ( PersistenceManager.class.isAssignableFrom( type ) && type.isInstance( persistenceManager ) )
{
return type.cast( persistenceManager );
}
else if ( ThreadToStatementContextBridge.class.isAssignableFrom( type )
&& type.isInstance( statementContextProvider ) )
{
return type.cast( statementContextProvider );
}
else if ( CacheAccessBackDoor.class.isAssignableFrom( type ) && type.isInstance( cacheBridge ) )
{
return type.cast( cacheBridge );
}
else if ( StoreLockerLifecycleAdapter.class.isAssignableFrom( type ) && type.isInstance( storeLocker ) )
{
return type.cast( storeLocker );
}
else if ( IndexManager.class.equals( type )&& type.isInstance( indexManager ) )
{
return type.cast( indexManager );
}
else if ( IndexingService.class.isAssignableFrom( type )
&& type.isInstance( neoDataSource.getIndexService() ) )
{
return type.cast( neoDataSource.getIndexService() );
}
else if ( JobScheduler.class.isAssignableFrom( type ) && type.isInstance( jobScheduler ) )
{
return type.cast( jobScheduler );
}
else if ( LabelScanStore.class.isAssignableFrom( type )
&& type.isInstance( neoDataSource.getLabelScanStore() ) )
{
return type.cast( neoDataSource.getLabelScanStore() );
}
else if ( NeoStoreProvider.class.isAssignableFrom( type ) )
{
return type.cast( neoDataSource );
}
else if ( IdGeneratorFactory.class.isAssignableFrom( type ) )
{
return type.cast( idGeneratorFactory );
}
else if ( Monitors.class.isAssignableFrom( type ) )
{
return type.cast( monitors );
}
else if ( RemoteTxHook.class.isAssignableFrom( type ) )
{
return type.cast( txHook );
}
else if ( DependencyResolver.class.equals( type ) )
{
return type.cast( DependencyResolverImpl.this );
}
else if ( KernelHealth.class.isAssignableFrom( type ) )
{
return (T) kernelHealth;
}
return null;
}
@Override
public <T> T resolveDependency( Class<T> type, SelectionStrategy selector )
{
// Try known single dependencies
T result = resolveKnownSingleDependency( type );
if ( result != null )
{
return selector.select( type, Iterables.option( result ) );
}
// Try with kernel extensions
return kernelExtensions.resolveDependency( type, selector );
}
}
class ConfigurationChangedRestarter extends LifecycleAdapter
{
private final ConfigurationChangeListener listener = new ConfigurationChangeListener()
{
Executor executor = Executors.newSingleThreadExecutor( new DaemonThreadFactory( "Database configuration " +
"restart" ) );
@Override
public void notifyConfigurationChanges( final Iterable<ConfigurationChange> change )
{
executor.execute( new Runnable()
{
@Override
public void run()
{
// Restart
try
{
life.stop();
life.start();
msgLog.logMessage( "Database restarted with the following configuration changes:" +
change );
}
catch ( LifecycleException e )
{
msgLog.logMessage( "Could not restart database", e );
}
}
} );
}
};
@Override
public void start() throws Throwable
{
config.addConfigurationChangeListener( listener );
}
@Override
public void stop() throws Throwable
{
config.removeConfigurationChangeListener( listener );
}
}
@Override
public ResourceIterable<Node> findNodesByLabelAndProperty( final Label myLabel, final String key, final Object value )
{
return new ResourceIterable<Node>()
{
@Override
public ResourceIterator<Node> iterator()
{
return nodesByLabelAndProperty( myLabel, key, value );
}
};
}
private ResourceIterator<Node> nodesByLabelAndProperty( Label myLabel, String key, Object value )
{
Statement statement = statementContextProvider.instance();
ReadOperations readOps = statement.readOperations();
int propertyId = readOps.propertyKeyGetForName( key );
int labelId = readOps.labelGetForName( myLabel.name() );
if ( propertyId == NO_SUCH_PROPERTY_KEY || labelId == NO_SUCH_LABEL )
{
statement.close();
return IteratorUtil.emptyIterator();
}
IndexDescriptor descriptor = findAnyIndexByLabelAndProperty( readOps, propertyId, labelId );
try
{
if ( null != descriptor )
{
// Ha! We found an index - let's use it to find matching nodes
return map2nodes( readOps.nodesGetFromIndexLookup( descriptor, value ), statement );
}
}
catch ( IndexNotFoundKernelException e )
{
// weird at this point but ignore and fallback to a label scan
}
return getNodesByLabelAndPropertyWithoutIndex( propertyId, value, statement, labelId );
}
private IndexDescriptor findAnyIndexByLabelAndProperty( ReadOperations readOps, int propertyId, int labelId )
{
IndexDescriptor descriptor = findUniqueIndexByLabelAndProperty( readOps, labelId, propertyId );
if ( null == descriptor )
{
descriptor = findRegularIndexByLabelAndProperty( readOps, labelId, propertyId );
}
return descriptor;
}
private IndexDescriptor findUniqueIndexByLabelAndProperty( ReadOperations readOps, int labelId, int propertyId )
{
try
{
IndexDescriptor descriptor = readOps.indexesGetForLabelAndPropertyKey( labelId, propertyId );
if ( readOps.indexGetState( descriptor ) == InternalIndexState.ONLINE )
{
// Ha! We found an index - let's use it to find matching nodes
return descriptor;
}
}
catch ( SchemaRuleNotFoundException | IndexNotFoundKernelException e )
{
// If we don't find a matching index rule, we'll scan all nodes and filter manually (below)
}
return null;
}
private IndexDescriptor findRegularIndexByLabelAndProperty( ReadOperations readOps, int labelId, int propertyId )
{
try
{
IndexDescriptor descriptor = readOps.indexesGetForLabelAndPropertyKey( labelId, propertyId );
if ( readOps.indexGetState( descriptor ) == InternalIndexState.ONLINE )
{
// Ha! We found an index - let's use it to find matching nodes
return descriptor;
}
}
catch ( SchemaRuleNotFoundException | IndexNotFoundKernelException e )
{
// If we don't find a matching index rule, we'll scan all nodes and filter manually (below)
}
return null;
}
private ResourceIterator<Node> getNodesByLabelAndPropertyWithoutIndex( int propertyId, Object value,
Statement statement, int labelId )
{
return map2nodes(
new PropertyValueFilteringNodeIdIterator(
statement.readOperations().nodesGetForLabel( labelId ),
statement.readOperations(), propertyId, value ), statement );
}
private ResourceIterator<Node> map2nodes( PrimitiveLongIterator input, Statement statement )
{
return ResourceClosingIterator.newResourceIterator( statement, map( new FunctionFromPrimitiveLong<Node>()
{
@Override
public Node apply( long id )
{
return getNodeById( id );
}
}, input ) );
}
private static class PropertyValueFilteringNodeIdIterator extends AbstractPrimitiveLongIterator
{
private final PrimitiveLongIterator nodesWithLabel;
private final ReadOperations statement;
private final int propertyKeyId;
private final Object value;
PropertyValueFilteringNodeIdIterator( PrimitiveLongIterator nodesWithLabel, ReadOperations statement,
int propertyKeyId, Object value )
{
this.nodesWithLabel = nodesWithLabel;
this.statement = statement;
this.propertyKeyId = propertyKeyId;
this.value = value;
computeNext();
}
@Override
protected void computeNext()
{
for ( boolean hasNext = nodesWithLabel.hasNext(); hasNext; hasNext = nodesWithLabel.hasNext() )
{
long nextValue = nodesWithLabel.next();
try
{
if ( statement.nodeGetProperty( nextValue, propertyKeyId ).valueEquals( value ) )
{
next( nextValue );
return;
}
}
catch ( EntityNotFoundException e )
{
// continue to the next node
}
}
endReached();
}
}
@Override
public TraversalDescription traversalDescription()
{
return new MonoDirectionalTraversalDescription(statementContextProvider);
}
@Override
public BidirectionalTraversalDescription bidirectionalTraversalDescription()
{
return new BidirectionalTraversalDescriptionImpl(statementContextProvider);
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_InternalAbstractGraphDatabase.java
|
5,610
|
{
@Override
protected HighlyAvailableGraphDatabase createResource( TargetDirectory.TestDirectory dir ) throws Exception
{
return (HighlyAvailableGraphDatabase) new HighlyAvailableGraphDatabaseFactory().
newHighlyAvailableDatabaseBuilder( dir.directory().getAbsolutePath() )
.setConfig( ClusterSettings.server_id, "1" )
.setConfig( ClusterSettings.initial_hosts, ":5001" )
.newGraphDatabase();
}
@Override
protected void disposeResource( HighlyAvailableGraphDatabase resource )
{
resource.shutdown();
}
};
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_HaKernelDataTest.java
|
5,611
|
public class HaKernelDataTest
{
@Test
public void shouldReturnHaGraphDbFromKernelData() throws Exception
{
// given
HighlyAvailableGraphDatabase haGraphDb = ha.getResource();
KernelData kernelData = haGraphDb.getDependencyResolver().resolveDependency( KernelData.class );
// then
assertSame( kernelData.graphDatabase(), haGraphDb );
}
@Rule
public final ManagedResource<HighlyAvailableGraphDatabase> ha = new ManagedResource<HighlyAvailableGraphDatabase>()
{
@Override
protected HighlyAvailableGraphDatabase createResource( TargetDirectory.TestDirectory dir ) throws Exception
{
return (HighlyAvailableGraphDatabase) new HighlyAvailableGraphDatabaseFactory().
newHighlyAvailableDatabaseBuilder( dir.directory().getAbsolutePath() )
.setConfig( ClusterSettings.server_id, "1" )
.setConfig( ClusterSettings.initial_hosts, ":5001" )
.newGraphDatabase();
}
@Override
protected void disposeResource( HighlyAvailableGraphDatabase resource )
{
resource.shutdown();
}
};
}
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_HaKernelDataTest.java
|
5,612
|
public class GuardPerformanceImpact
{
private static String dir = forTest( GuardPerformanceImpact.class ).makeGraphDbDir().getAbsolutePath();
private static final int RUNS = 10;
private static final int PER_TX = 10000;
private static final int TX = 100;
private enum Type
{
without, enabled, activeTimeout, activeOpscount
}
public static void main( String[] args ) throws IOException
{
test( Type.enabled );
}
private static void test( final Type type ) throws IOException
{
switch ( type )
{
case without:
for ( int i = 0; i < RUNS; i++ )
{
System.err.println( withoutGuard() );
}
break;
case enabled:
for ( int i = 0; i < RUNS; i++ )
{
System.err.println( guardEnabled() );
}
break;
case activeOpscount:
for ( int i = 0; i < RUNS; i++ )
{
System.err.println( guardEnabledAndActiveOpsCount() );
}
break;
case activeTimeout:
for ( int i = 0; i < RUNS; i++ )
{
System.err.println( guardEnabledAndActiveTimeout() );
}
break;
}
}
private static long withoutGuard() throws IOException
{
final GraphDatabaseAPI db = prepare( false );
try
{
final long start = currentTimeMillis();
createData( db );
return currentTimeMillis() - start;
}
finally
{
cleanup( db );
}
}
private static GraphDatabaseAPI prepare( boolean insertGuard ) throws IOException
{
return (GraphDatabaseAPI) new GraphDatabaseFactory().newEmbeddedDatabaseBuilder( dir )
.setConfig( stringMap( "enable_execution_guard", valueOf( insertGuard ) ) ).newGraphDatabase();
}
private static void createData( final GraphDatabaseAPI db )
{
for ( int j = 0; j < TX; j++ )
{
final Transaction tx = db.beginTx();
for ( int i = 0; i < PER_TX; i++ )
{
db.createNode();
}
tx.success();
tx.finish();
}
}
private static void cleanup( final GraphDatabaseAPI db ) throws IOException
{
db.shutdown();
FileUtils.deleteRecursively( new File( dir ) );
}
private static long guardEnabled() throws IOException
{
final GraphDatabaseAPI db = prepare( true );
try
{
final long start = currentTimeMillis();
createData( db );
return currentTimeMillis() - start;
}
finally
{
cleanup( db );
}
}
private static long guardEnabledAndActiveOpsCount() throws IOException
{
final GraphDatabaseAPI db = prepare( true );
try
{
final long start = currentTimeMillis();
db.getDependencyResolver().resolveDependency( Guard.class ).startOperationsCount( MAX_VALUE );
createData( db );
return currentTimeMillis() - start;
}
finally
{
cleanup( db );
}
}
private static long guardEnabledAndActiveTimeout() throws IOException
{
final GraphDatabaseAPI db = prepare( true );
try
{
final long start = currentTimeMillis();
db.getDependencyResolver().resolveDependency( Guard.class ).startTimeout( MAX_VALUE );
createData( db );
return currentTimeMillis() - start;
}
finally
{
cleanup( db );
}
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_GuardPerformanceImpact.java
|
5,613
|
public class GraphDatabaseDependencies implements InternalAbstractGraphDatabase.Dependencies
{
private final Logging logging;
private final Iterable<Class<?>> settingsClasses;
private final Iterable<KernelExtensionFactory<?>> kernelExtensions;
private final Iterable<CacheProvider> cacheProviders;
private final Iterable<TransactionInterceptorProvider> transactionInterceptorProviders;
@SuppressWarnings( "deprecation" )
public GraphDatabaseDependencies(
Logging logging,
Iterable<Class<?>> settingsClasses,
Iterable<KernelExtensionFactory<?>> kernelExtensions, Iterable<CacheProvider> cacheProviders,
Iterable<TransactionInterceptorProvider> transactionInterceptorProviders )
{
this.logging = logging;
this.settingsClasses = settingsClasses;
this.kernelExtensions = kernelExtensions;
this.cacheProviders = cacheProviders;
this.transactionInterceptorProviders = transactionInterceptorProviders;
}
@Override
public Logging logging()
{
return logging;
}
@Override
public Iterable<Class<?>> settingsClasses()
{
return settingsClasses;
}
@Override
public Iterable<KernelExtensionFactory<?>> kernelExtensions()
{
return kernelExtensions;
}
@Override
public Iterable<CacheProvider> cacheProviders()
{
return cacheProviders;
}
@Override
public Iterable<TransactionInterceptorProvider> transactionInterceptorProviders()
{
return transactionInterceptorProviders;
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_GraphDatabaseDependencies.java
|
5,614
|
{
final Iterator<PropertyContainer> startEntities = start.iterator();
int lastReturned = 2;
@Override
protected PropertyContainer fetchNextOrNull()
{
if ( startEntities.hasNext() ) return startEntities.next();
switch ( lastReturned-- )
{
case 2: return endNode;
case 1: return lastRelationship;
default: return null;
}
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_ExtendedPath.java
|
5,615
|
{
final Iterator<Node> startNodes = start.reverseNodes().iterator();
boolean endReturned;
@Override
protected Node fetchNextOrNull()
{
if ( !endReturned )
{
endReturned = true;
return endNode;
}
return startNodes.hasNext() ? startNodes.next() : null;
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_ExtendedPath.java
|
5,616
|
{
@Override
public Iterator<Node> iterator()
{
return new PrefetchingIterator<Node>()
{
final Iterator<Node> startNodes = start.reverseNodes().iterator();
boolean endReturned;
@Override
protected Node fetchNextOrNull()
{
if ( !endReturned )
{
endReturned = true;
return endNode;
}
return startNodes.hasNext() ? startNodes.next() : null;
}
};
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_ExtendedPath.java
|
5,617
|
{
final Iterator<Node> startNodes = start.nodes().iterator();
boolean lastReturned;
@Override
protected Node fetchNextOrNull()
{
if ( startNodes.hasNext() ) return startNodes.next();
if ( !lastReturned )
{
lastReturned = true;
return endNode;
}
return null;
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_ExtendedPath.java
|
5,618
|
{
@Override
public Iterator<Node> iterator()
{
return new PrefetchingIterator<Node>()
{
final Iterator<Node> startNodes = start.nodes().iterator();
boolean lastReturned;
@Override
protected Node fetchNextOrNull()
{
if ( startNodes.hasNext() ) return startNodes.next();
if ( !lastReturned )
{
lastReturned = true;
return endNode;
}
return null;
}
};
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_ExtendedPath.java
|
5,619
|
{
final Iterator<Relationship> startRelationships = start.reverseRelationships().iterator();
boolean endReturned;
@Override
protected Relationship fetchNextOrNull()
{
if ( !endReturned )
{
endReturned = true;
return lastRelationship;
}
return startRelationships.hasNext() ? startRelationships.next() : null;
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_ExtendedPath.java
|
5,620
|
{
@Override
public Iterator<Relationship> iterator()
{
return new PrefetchingIterator<Relationship>()
{
final Iterator<Relationship> startRelationships = start.reverseRelationships().iterator();
boolean endReturned;
@Override
protected Relationship fetchNextOrNull()
{
if ( !endReturned )
{
endReturned = true;
return lastRelationship;
}
return startRelationships.hasNext() ? startRelationships.next() : null;
}
};
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_ExtendedPath.java
|
5,621
|
{
final Iterator<Relationship> startRelationships = start.relationships().iterator();
boolean lastReturned;
@Override
protected Relationship fetchNextOrNull()
{
if ( startRelationships.hasNext() ) return startRelationships.next();
if ( !lastReturned )
{
lastReturned = true;
return lastRelationship;
}
return null;
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_ExtendedPath.java
|
5,622
|
{
@Override
public Iterator<Relationship> iterator()
{
return new PrefetchingIterator<Relationship>()
{
final Iterator<Relationship> startRelationships = start.relationships().iterator();
boolean lastReturned;
@Override
protected Relationship fetchNextOrNull()
{
if ( startRelationships.hasNext() ) return startRelationships.next();
if ( !lastReturned )
{
lastReturned = true;
return lastRelationship;
}
return null;
}
};
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_ExtendedPath.java
|
5,623
|
public class ExtendedPath implements Path
{
private final Path start;
private final Relationship lastRelationship;
private final Node endNode;
public ExtendedPath( Path start, Relationship lastRelationship )
{
this.start = start;
this.lastRelationship = lastRelationship;
this.endNode = lastRelationship.getOtherNode( start.endNode() );
}
@Override
public Node startNode()
{
return start.startNode();
}
@Override
public Node endNode()
{
return endNode;
}
@Override
public Relationship lastRelationship()
{
return lastRelationship;
}
@Override
public Iterable<Relationship> relationships()
{
return new Iterable<Relationship>()
{
@Override
public Iterator<Relationship> iterator()
{
return new PrefetchingIterator<Relationship>()
{
final Iterator<Relationship> startRelationships = start.relationships().iterator();
boolean lastReturned;
@Override
protected Relationship fetchNextOrNull()
{
if ( startRelationships.hasNext() ) return startRelationships.next();
if ( !lastReturned )
{
lastReturned = true;
return lastRelationship;
}
return null;
}
};
}
};
}
@Override
public Iterable<Relationship> reverseRelationships()
{
return new Iterable<Relationship>()
{
@Override
public Iterator<Relationship> iterator()
{
return new PrefetchingIterator<Relationship>()
{
final Iterator<Relationship> startRelationships = start.reverseRelationships().iterator();
boolean endReturned;
@Override
protected Relationship fetchNextOrNull()
{
if ( !endReturned )
{
endReturned = true;
return lastRelationship;
}
return startRelationships.hasNext() ? startRelationships.next() : null;
}
};
}
};
}
@Override
public Iterable<Node> nodes()
{
return new Iterable<Node>()
{
@Override
public Iterator<Node> iterator()
{
return new PrefetchingIterator<Node>()
{
final Iterator<Node> startNodes = start.nodes().iterator();
boolean lastReturned;
@Override
protected Node fetchNextOrNull()
{
if ( startNodes.hasNext() ) return startNodes.next();
if ( !lastReturned )
{
lastReturned = true;
return endNode;
}
return null;
}
};
}
};
}
@Override
public Iterable<Node> reverseNodes()
{
return new Iterable<Node>()
{
@Override
public Iterator<Node> iterator()
{
return new PrefetchingIterator<Node>()
{
final Iterator<Node> startNodes = start.reverseNodes().iterator();
boolean endReturned;
@Override
protected Node fetchNextOrNull()
{
if ( !endReturned )
{
endReturned = true;
return endNode;
}
return startNodes.hasNext() ? startNodes.next() : null;
}
};
}
};
}
@Override
public int length()
{
return start.length()+1;
}
@Override
public Iterator<PropertyContainer> iterator()
{
return new PrefetchingIterator<PropertyContainer>()
{
final Iterator<PropertyContainer> startEntities = start.iterator();
int lastReturned = 2;
@Override
protected PropertyContainer fetchNextOrNull()
{
if ( startEntities.hasNext() ) return startEntities.next();
switch ( lastReturned-- )
{
case 2: return endNode;
case 1: return lastRelationship;
default: return null;
}
}
};
}
public static Path extend( Path path, Relationship withRelationship )
{
return new ExtendedPath( path, withRelationship );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_ExtendedPath.java
|
5,624
|
{
public boolean accept( Relationship rel )
{
Exclusion exclude = exclusion.get( rel.getType().name() );
exclude = (exclude == null) ? defaultExclusion
: exclude;
return exclude.accept( node, rel );
}
} );
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StandardExpander.java
|
5,625
|
ALL( null, "!" )
{
@Override
public boolean accept( Node start, Relationship rel )
{
return false;
}
},
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StandardExpander.java
|
5,626
|
INCOMING( Direction.OUTGOING )
{
@Override
Exclusion reversed()
{
return OUTGOING;
}
},
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StandardExpander.java
|
5,627
|
{
@Override
public long maxCount()
{
return 0;
}
@Override
public void close() throws IOException
{
}
@Override
public Iterator<NodeLabelRange> iterator()
{
return emptyIterator();
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_direct_AllEntriesLabelScanReader.java
|
5,628
|
public class UniqueConstraintHaIT
{
@Rule
public ClusterRule clusterRule = new ClusterRule( getClass() );
@Test
public void shouldCreateUniqueConstraintOnMaster() throws Exception
{
// given
ClusterManager.ManagedCluster cluster = clusterRule.startCluster();
HighlyAvailableGraphDatabase master = cluster.getMaster();
// when
try ( Transaction tx = master.beginTx() )
{
master.schema().constraintFor( label( "Label1" ) ).assertPropertyIsUnique( "key1" ).create();
tx.success();
}
cluster.sync();
// then
for ( HighlyAvailableGraphDatabase clusterMember : cluster.getAllMembers() )
{
try ( Transaction tx = clusterMember.beginTx() )
{
ConstraintDefinition constraint =
single( clusterMember.schema().getConstraints( label( "Label1" ) ) );
assertEquals( "key1", single( constraint.getPropertyKeys() ) );
tx.success();
}
}
}
@Test
public void shouldNotBePossibleToCreateConstraintsDirectlyOnSlaves() throws Exception
{
// given
ClusterManager.ManagedCluster cluster = clusterRule.startCluster();
HighlyAvailableGraphDatabase slave = cluster.getAnySlave();
// when
try ( Transaction ignored = slave.beginTx() )
{
slave.schema().constraintFor( label( "Label1" ) ).assertPropertyIsUnique( "key1" ).create();
fail( "We expected to not be able to create a constraint on a slave in a cluster." );
}
catch ( Exception e )
{
assertThat(e, instanceOf(InvalidTransactionTypeException.class));
}
}
@Test
public void shouldRemoveConstraints() throws Exception
{
// given
ClusterManager.ManagedCluster cluster = clusterRule.startCluster();
HighlyAvailableGraphDatabase master = cluster.getMaster();
try ( Transaction tx = master.beginTx() )
{
master.schema().constraintFor( label( "User" ) ).assertPropertyIsUnique( "name" ).create();
tx.success();
}
cluster.sync();
// and given I have some data for the constraint
createUser( cluster.getAnySlave(), "Bob" );
// when
try ( Transaction tx = master.beginTx() )
{
single( master.schema().getConstraints() ).drop();
tx.success();
}
cluster.sync();
// then the constraint should be gone, and not be enforced anymore
for ( HighlyAvailableGraphDatabase clusterMember : cluster.getAllMembers() )
{
try ( Transaction tx = clusterMember.beginTx() )
{
assertEquals( count(clusterMember.schema().getConstraints()), 0);
assertEquals( count(clusterMember.schema().getIndexes()), 0);
createUser( clusterMember, "Bob" );
tx.success();
}
}
}
@Test
public void shouldNotAllowOldUncommittedTransactionsToResumeAndViolateConstraint() throws Exception
{
// Given
ClusterManager.ManagedCluster cluster = clusterRule.startCluster(stringMap(
HaSettings.read_timeout.name(), "4000s" ));
HighlyAvailableGraphDatabase slave = cluster.getAnySlave();
HighlyAvailableGraphDatabase master = cluster.getMaster();
TransactionManager txManager = slave.getDependencyResolver().resolveDependency( TransactionManager.class );
// And given there is a user named bob
createUser(master, "Bob");
// And given that I begin a transaction that will create another user named bob
slave.beginTx();
slave.createNode( label("User") ).setProperty( "name", "Bob" );
javax.transaction.Transaction slaveTx = txManager.suspend();
// When I create a constraint for unique user names
try(Transaction tx = master.beginTx())
{
master.schema().constraintFor( label("User") ).assertPropertyIsUnique( "name" ).create();
tx.success();
}
// Then the transaction started on the slave should fail on commit, with an integrity error
txManager.resume( slaveTx );
try
{
slaveTx.commit();
fail( "Expected this commit to fail :(" );
}
catch( Exception e )
{
XAException cause = (XAException) e.getCause();
assertThat(cause.errorCode, equalTo(XAException.XA_RBINTEGRITY));
}
// And then both master and slave should keep working, accepting reads
assertOneBob( master );
cluster.sync();
assertOneBob( slave );
// And then I should be able to perform new write transactions, on both master and slave
createUser( slave, "Steven" );
createUser( master, "Caroline" );
}
@Test
public void newSlaveJoiningClusterShouldNotAcceptOperationsUntilConstraintIsOnline() throws Throwable
{
// Given
ClusterManager.ManagedCluster cluster = clusterRule.startCluster();
HighlyAvailableGraphDatabase master = cluster.getMaster();
HighlyAvailableGraphDatabase slave = cluster.getAnySlave();
File slaveStoreDirectory = cluster.getStoreDir( slave );
// Crash the slave
ClusterManager.RepairKit shutdownSlave = cluster.shutdown( slave );
deleteRecursively( slaveStoreDirectory );
try(Transaction tx = master.beginTx())
{
master.schema().constraintFor( label("User") ).assertPropertyIsUnique( "name" ).create();
tx.success();
}
// When
slave = shutdownSlave.repair();
// Then
try( Transaction ignored = slave.beginTx() )
{
assertThat(single( slave.schema().getConstraints() ), instanceOf(PropertyUniqueConstraintDefinition.class));
PropertyUniqueConstraintDefinition constraint =
(PropertyUniqueConstraintDefinition)single(slave.schema().getConstraints());
assertThat(single(constraint.getPropertyKeys()), equalTo("name"));
assertThat(constraint.getLabel(), equalTo(label("User")));
}
}
private void createUser( HighlyAvailableGraphDatabase db, String name )
{
try(Transaction tx = db.beginTx())
{
db.createNode( label("User") ).setProperty( "name", name );
tx.success();
}
}
private void assertOneBob( HighlyAvailableGraphDatabase db)
{
try(Transaction tx = db.beginTx())
{
assertThat( asList( db.findNodesByLabelAndProperty( label( "User" ), "name", "Bob" ) ).size(),
equalTo(1));
tx.success();
}
}
}
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_api_UniqueConstraintHaIT.java
|
5,629
|
public class TransactionStatementSharingTest
{
@Test
public void shouldShareStatementStateForConcurrentReadStatementAndReadStatement() throws Exception
{
// given
KernelTransaction tx = kernelTransaction();
ReadOperations stmt1 = tx.acquireStatement().readOperations();
// when
ReadOperations stmt2 = tx.acquireStatement().readOperations();
// then
assertSame( stmt1, stmt2 );
}
@Test
public void shouldShareStatementStateForConcurrentReadStatementAndDataStatement() throws Exception
{
// given
KernelTransaction tx = kernelTransaction();
ReadOperations stmt1 = tx.acquireStatement().readOperations();
// when
DataWriteOperations stmt2 = tx.acquireStatement().dataWriteOperations();
// then
assertSame( stmt1, stmt2 );
}
@Test
public void shouldShareStatementStateForConcurrentReadStatementAndSchemaStatement() throws Exception
{
// given
KernelTransaction tx = kernelTransaction();
ReadOperations stmt1 = tx.acquireStatement().readOperations();
// when
SchemaWriteOperations stmt2 = tx.acquireStatement().schemaWriteOperations();
// then
assertSame( stmt1, stmt2 );
}
@Test
public void shouldShareStatementStateForConcurrentDataStatementAndReadStatement() throws Exception
{
// given
KernelTransaction tx = kernelTransaction();
DataWriteOperations stmt1 = tx.acquireStatement().dataWriteOperations();
// when
ReadOperations stmt2 = tx.acquireStatement().readOperations();
// then
assertSame( stmt1, stmt2 );
}
@Test
public void shouldShareStatementStateForConcurrentDataStatementAndDataStatement() throws Exception
{
// given
KernelTransaction tx = kernelTransaction();
DataWriteOperations stmt1 = tx.acquireStatement().dataWriteOperations();
// when
DataWriteOperations stmt2 = tx.acquireStatement().dataWriteOperations();
// then
assertSame( stmt1, stmt2 );
}
@Test
public void shouldShareStatementStateForConcurrentSchemaStatementAndReadStatement() throws Exception
{
// given
KernelTransaction tx = kernelTransaction();
SchemaWriteOperations stmt1 = tx.acquireStatement().schemaWriteOperations();
// when
ReadOperations stmt2 = tx.acquireStatement().readOperations();
// then
assertSame( stmt1, stmt2 );
}
@Test
public void shouldShareStatementStateForConcurrentSchemaStatementAndSchemaStatement() throws Exception
{
// given
KernelTransaction tx = kernelTransaction();
SchemaWriteOperations stmt1 = tx.acquireStatement().schemaWriteOperations();
// when
SchemaWriteOperations stmt2 = tx.acquireStatement().schemaWriteOperations();
// then
assertSame( stmt1, stmt2 );
}
@Test
public void shouldNotShareStateForSequentialReadStatementAndReadStatement() throws Exception
{
// given
KernelTransaction tx = kernelTransaction();
Statement statement = tx.acquireStatement();
ReadOperations ops1 = statement.readOperations();
statement.close();
// when
ReadOperations ops2 = tx.acquireStatement().readOperations();
// then
assertNotSame( ops1, ops2 );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_api_TransactionStatementSharingTest.java
|
5,630
|
public class TransactionStatementSequenceTest
{
@Test
public void shouldAllowReadStatementAfterReadStatement() throws Exception
{
// given
KernelTransaction tx = kernelTransaction();
tx.acquireStatement().readOperations();
// when / then
tx.acquireStatement().readOperations();
}
@Test
public void shouldAllowDataStatementAfterReadStatement() throws Exception
{
// given
KernelTransaction tx = kernelTransaction();
tx.acquireStatement().readOperations();
// when / then
tx.acquireStatement().dataWriteOperations();
}
@Test
public void shouldAllowSchemaStatementAfterReadStatement() throws Exception
{
// given
KernelTransaction tx = kernelTransaction();
tx.acquireStatement().readOperations();
// when / then
tx.acquireStatement().schemaWriteOperations();
}
@Test
public void shouldRejectSchemaStatementAfterDataStatement() throws Exception
{
// given
KernelTransaction tx = kernelTransaction();
tx.acquireStatement().dataWriteOperations();
// when
try
{
tx.acquireStatement().schemaWriteOperations();
fail( "expected exception" );
}
// then
catch ( InvalidTransactionTypeKernelException e )
{
assertEquals( "Cannot perform schema updates in a transaction that has performed data updates.",
e.getMessage() );
}
}
@Test
public void shouldRejectDataStatementAfterSchemaStatement() throws Exception
{
// given
KernelTransaction tx = kernelTransaction();
tx.acquireStatement().schemaWriteOperations();
// when
try
{
tx.acquireStatement().dataWriteOperations();
fail( "expected exception" );
}
// then
catch ( InvalidTransactionTypeKernelException e )
{
assertEquals( "Cannot perform data updates in a transaction that has performed schema updates.",
e.getMessage() );
}
}
@Test
public void shouldAllowDataStatementAfterDataStatement() throws Exception
{
// given
KernelTransaction tx = kernelTransaction();
tx.acquireStatement().dataWriteOperations();
// when / then
tx.acquireStatement().dataWriteOperations();
}
@Test
public void shouldAllowSchemaStatementAfterSchemaStatement() throws Exception
{
// given
KernelTransaction tx = kernelTransaction();
tx.acquireStatement().schemaWriteOperations();
// when / then
tx.acquireStatement().schemaWriteOperations();
}
@Test
public void shouldAllowReadStatementAfterDataStatement() throws Exception
{
// given
KernelTransaction tx = kernelTransaction();
tx.acquireStatement().dataWriteOperations();
// when / then
tx.acquireStatement().readOperations();
}
@Test
public void shouldAllowReadStatementAfterSchemaStatement() throws Exception
{
// given
KernelTransaction tx = kernelTransaction();
tx.acquireStatement().schemaWriteOperations();
// when / then
tx.acquireStatement().readOperations();
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_api_TransactionStatementSequenceTest.java
|
5,631
|
public final class StatementTokenNameLookup implements TokenNameLookup
{
private final ReadOperations statement;
public StatementTokenNameLookup( ReadOperations statement )
{
this.statement = statement;
}
/**
* Returns the label name for the given label id. In case of downstream failure, returns label[id].
*/
@Override
public String labelGetName( int labelId )
{
try
{
return statement.labelGetName( labelId );
}
catch ( LabelNotFoundKernelException e )
{
return "[" + labelId + "]";
}
}
/**
* Returns the name of a property given its property key id. In case of downstream failure, returns property[id].
*/
@Override
public String propertyKeyGetName( int propertyKeyId )
{
try
{
return statement.propertyKeyGetName( propertyKeyId );
}
catch ( PropertyKeyIdNotFoundKernelException e )
{
return "[" + propertyKeyId + "]";
}
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_StatementTokenNameLookup.java
|
5,632
|
public final class StatementConstants
{
public static final int NO_SUCH_LABEL = -1;
public static final int NO_SUCH_PROPERTY_KEY = -1;
public static final long NO_SUCH_NODE = -1;
private StatementConstants()
{
throw new UnsupportedOperationException();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_StatementConstants.java
|
5,633
|
public static class ControllingIndexProviderFactory extends KernelExtensionFactory<IndexProviderDependencies>
{
private final Map<GraphDatabaseService, SchemaIndexProvider> perDbIndexProvider;
private final Predicate<GraphDatabaseService> injectLatchPredicate;
public ControllingIndexProviderFactory( Map<GraphDatabaseService, SchemaIndexProvider> perDbIndexProvider,
Predicate<GraphDatabaseService> injectLatchPredicate)
{
super( CONTROLLED_PROVIDER_DESCRIPTOR.getKey() );
this.perDbIndexProvider = perDbIndexProvider;
this.injectLatchPredicate = injectLatchPredicate;
}
@Override
public Lifecycle newKernelExtension( SchemaIndexHaIT.IndexProviderDependencies deps ) throws Throwable
{
if(injectLatchPredicate.accept( deps.db() ))
{
ControlledSchemaIndexProvider provider = new ControlledSchemaIndexProvider(
new LuceneSchemaIndexProvider( DirectoryFactory.PERSISTENT, deps.config() ) );
perDbIndexProvider.put( deps.db(), provider );
return provider;
}
else
{
return new LuceneSchemaIndexProvider( DirectoryFactory.PERSISTENT, deps.config() );
}
}
}
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_api_SchemaIndexHaIT.java
|
5,634
|
private static class ControlledSchemaIndexProvider extends SchemaIndexProvider
{
private final SchemaIndexProvider delegate;
private final DoubleLatch latch = new DoubleLatch();
public ControlledSchemaIndexProvider(SchemaIndexProvider delegate)
{
super( CONTROLLED_PROVIDER_DESCRIPTOR, 100 /*we want it to always win*/ );
this.delegate = delegate;
}
@Override
public IndexPopulator getPopulator( long indexId, IndexDescriptor descriptor, IndexConfiguration config )
{
return new ControlledIndexPopulator( delegate.getPopulator( indexId, descriptor, config ), latch );
}
@Override
public IndexAccessor getOnlineAccessor( long indexId, IndexConfiguration config ) throws IOException
{
return delegate.getOnlineAccessor(indexId, config);
}
@Override
public InternalIndexState getInitialState( long indexId )
{
return delegate.getInitialState(indexId);
}
@Override
public String getPopulationFailure( long indexId ) throws IllegalStateException
{
return delegate.getPopulationFailure( indexId );
}
}
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_api_SchemaIndexHaIT.java
|
5,635
|
private static class ControlledIndexPopulator implements IndexPopulator
{
private final DoubleLatch latch;
private final IndexPopulator delegate;
public ControlledIndexPopulator( IndexPopulator delegate, DoubleLatch latch )
{
this.delegate = delegate;
this.latch = latch;
}
@Override
public void create() throws IOException
{
delegate.create();
}
@Override
public void drop() throws IOException
{
delegate.drop();
}
@Override
public void add( long nodeId, Object propertyValue ) throws IndexEntryConflictException, IOException
{
delegate.add(nodeId, propertyValue);
latch.startAndAwaitFinish();
}
@Override
public void verifyDeferredConstraints( PropertyAccessor propertyAccessor ) throws Exception
{
delegate.verifyDeferredConstraints( propertyAccessor );
}
@Override
public IndexUpdater newPopulatingUpdater( PropertyAccessor propertyAccessor ) throws IOException
{
return delegate.newPopulatingUpdater( propertyAccessor );
}
@Override
public void close( boolean populationCompletedSuccessfully ) throws IOException
{
delegate.close(populationCompletedSuccessfully);
assertTrue( "Expected population to succeed :(", populationCompletedSuccessfully );
latch.finish();
}
@Override
public void markAsFailed( String failure ) throws IOException
{
delegate.markAsFailed( failure );
}
}
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_api_SchemaIndexHaIT.java
|
5,636
|
private static class ControlledGraphDatabaseFactory extends HighlyAvailableGraphDatabaseFactory
{
final Map<GraphDatabaseService,SchemaIndexProvider> perDbIndexProvider = new ConcurrentHashMap<>();
private final KernelExtensionFactory<?> factory;
public ControlledGraphDatabaseFactory()
{
factory = new ControllingIndexProviderFactory(perDbIndexProvider, Predicates.<GraphDatabaseService>TRUE());
}
private ControlledGraphDatabaseFactory( Predicate<GraphDatabaseService> dbsToControlIndexingOn )
{
factory = new ControllingIndexProviderFactory(perDbIndexProvider, dbsToControlIndexingOn);
}
@Override
public GraphDatabaseBuilder newHighlyAvailableDatabaseBuilder(String path)
{
getCurrentState().addKernelExtensions( Arrays.<KernelExtensionFactory<?>>asList( factory ) );
return super.newHighlyAvailableDatabaseBuilder( path );
}
void awaitPopulationStarted( GraphDatabaseService db )
{
ControlledSchemaIndexProvider provider = (ControlledSchemaIndexProvider) perDbIndexProvider.get( db );
if(provider != null ) provider.latch.awaitStart();
}
void triggerFinish( GraphDatabaseService db )
{
ControlledSchemaIndexProvider provider = (ControlledSchemaIndexProvider) perDbIndexProvider.get( db );
if(provider != null ) provider.latch.finish();
}
}
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_api_SchemaIndexHaIT.java
|
5,637
|
{
@Override
public boolean accept( GraphDatabaseService item )
{
return item instanceof HighlyAvailableGraphDatabase && ((HighlyAvailableGraphDatabase) item).isMaster();
}
};
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_api_SchemaIndexHaIT.java
|
5,638
|
public class SchemaIndexHaIT
{
@Test
public void creatingIndexOnMasterShouldHaveSlavesBuildItAsWell() throws Throwable
{
// GIVEN
ManagedCluster cluster = clusterRule.startCluster();
HighlyAvailableGraphDatabase master = cluster.getMaster();
Map<Object, Node> data = createSomeData( master );
// WHEN
IndexDefinition index = createIndex( master );
cluster.sync();
// THEN
awaitIndexOnline( index, cluster, data );
}
@Test
public void creatingIndexOnSlaveIsNotAllowed() throws Throwable
{
// GIVEN
ManagedCluster cluster = clusterRule.startCluster();
HighlyAvailableGraphDatabase slave = cluster.getAnySlave();
// WHEN
try
{
createIndex( slave );
fail( "should have thrown exception" );
}
catch ( ConstraintViolationException e )
{
// expected
}
}
@Test
public void indexPopulationJobsShouldContinueThroughRoleSwitch() throws Throwable
{
// GIVEN a cluster of 3
ControlledGraphDatabaseFactory dbFactory = new ControlledGraphDatabaseFactory();
ManagedCluster cluster = clusterRule.startCluster( dbFactory );
HighlyAvailableGraphDatabase firstMaster = cluster.getMaster();
// where the master gets some data created as well as an index
Map<Object, Node> data = createSomeData( firstMaster );
createIndex( firstMaster );
//dbFactory.awaitPopulationStarted( firstMaster );
dbFactory.triggerFinish( firstMaster );
// Pick a slave, pull the data and the index
HighlyAvailableGraphDatabase aSlave = cluster.getAnySlave();
aSlave.getDependencyResolver().resolveDependency( UpdatePuller.class ).pullUpdates();
// and await the index population to start. It will actually block as long as we want it to
dbFactory.awaitPopulationStarted( aSlave );
// WHEN we shut down the master
cluster.shutdown( firstMaster );
dbFactory.triggerFinish( aSlave );
cluster.await( masterAvailable( firstMaster ) );
// get the new master, which should be the slave we pulled from above
HighlyAvailableGraphDatabase newMaster = cluster.getMaster();
// THEN
assertEquals( "Unexpected new master", aSlave, newMaster );
try ( Transaction tx = newMaster.beginTx() )
{
IndexDefinition index = single( newMaster.schema().getIndexes() );
awaitIndexOnline( index, newMaster, data );
tx.success();
}
// FINALLY: let all db's finish
for ( HighlyAvailableGraphDatabase db : cluster.getAllMembers() )
{
dbFactory.triggerFinish( db );
}
}
@Test
public void populatingSchemaIndicesOnMasterShouldBeBroughtOnlineOnSlavesAfterStoreCopy() throws Throwable
{
/*
The master has an index that is currently populating.
Then a slave comes online and contacts the master to get copies of the store files.
Because the index is still populating, it won't be copied. Instead the slave will build its own.
We want to observe that the slave builds an index that eventually comes online.
*/
// GIVEN
ControlledGraphDatabaseFactory dbFactory = new ControlledGraphDatabaseFactory( IS_MASTER );
ManagedCluster cluster = clusterRule.startCluster( dbFactory );
try
{
cluster.await( allSeesAllAsAvailable() );
HighlyAvailableGraphDatabase slave = cluster.getAnySlave();
// A slave is offline, and has no store files
ClusterManager.RepairKit slaveDown = bringSlaveOfflineAndRemoveStoreFiles( cluster, slave );
// And I create an index on the master, and wait for population to start
HighlyAvailableGraphDatabase master = cluster.getMaster();
Map<Object, Node> data = createSomeData(master);
createIndex( master );
dbFactory.awaitPopulationStarted( master );
// WHEN the slave comes online before population has finished on the master
slave = slaveDown.repair();
cluster.await( allSeesAllAsAvailable(), 180 );
cluster.sync();
// THEN, population should finish successfully on both master and slave
dbFactory.triggerFinish( master );
// Check master
IndexDefinition index;
try ( Transaction tx = master.beginTx())
{
index = single( master.schema().getIndexes() );
awaitIndexOnline( index, master, data );
tx.success();
}
// Check slave
try ( Transaction tx = slave.beginTx() )
{
awaitIndexOnline( index, slave, data );
tx.success();
}
}
finally
{
for ( HighlyAvailableGraphDatabase db : cluster.getAllMembers() )
{
dbFactory.triggerFinish( db );
}
}
}
@Test
public void onlineSchemaIndicesOnMasterShouldBeBroughtOnlineOnSlavesAfterStoreCopy() throws Throwable
{
/*
The master has an index that is online.
Then a slave comes online and contacts the master to get copies of the store files.
Because the index is online, it should be copied, and the slave should successfully bring the index online.
*/
// GIVEN
ControlledGraphDatabaseFactory dbFactory = new ControlledGraphDatabaseFactory();
ManagedCluster cluster = clusterRule.startCluster( dbFactory );
cluster.await( allSeesAllAsAvailable(), 120 );
HighlyAvailableGraphDatabase slave = cluster.getAnySlave();
// All slaves in the cluster, except the one I care about, proceed as normal
proceedAsNormalWithIndexPopulationOnAllSlavesExcept( dbFactory, cluster, slave );
// A slave is offline, and has no store files
ClusterManager.RepairKit slaveDown = bringSlaveOfflineAndRemoveStoreFiles( cluster, slave );
// And I create an index on the master, and wait for population to start
HighlyAvailableGraphDatabase master = cluster.getMaster();
Map<Object, Node> data = createSomeData(master);
createIndex( master );
dbFactory.awaitPopulationStarted( master );
// And the population finishes
dbFactory.triggerFinish( master );
IndexDefinition index;
try ( Transaction tx = master.beginTx())
{
index = single( master.schema().getIndexes() );
awaitIndexOnline( index, master, data );
tx.success();
}
// WHEN the slave comes online after population has finished on the master
slave = slaveDown.repair();
cluster.await( allSeesAllAsAvailable() );
cluster.sync();
// THEN the index should work on the slave
dbFactory.triggerFinish( slave );
try ( Transaction tx = slave.beginTx() )
{
awaitIndexOnline( index, slave, data );
tx.success();
}
}
private void proceedAsNormalWithIndexPopulationOnAllSlavesExcept( ControlledGraphDatabaseFactory dbFactory,
ManagedCluster cluster,
HighlyAvailableGraphDatabase slaveToIgnore )
{
for ( HighlyAvailableGraphDatabase db : cluster.getAllMembers() )
{
if( db != slaveToIgnore && db.getInstanceState().equals( "SLAVE" ) )
{
dbFactory.triggerFinish( db );
}
}
}
@SuppressWarnings("ResultOfMethodCallIgnored")
private ClusterManager.RepairKit bringSlaveOfflineAndRemoveStoreFiles( ManagedCluster cluster, HighlyAvailableGraphDatabase slave ) throws IOException
{
ClusterManager.RepairKit slaveDown = cluster.shutdown(slave);
File storeDir = new File( slave.getStoreDir() );
deleteRecursively( storeDir );
storeDir.mkdir();
return slaveDown;
}
public static final Predicate<GraphDatabaseService> IS_MASTER = new Predicate<GraphDatabaseService>()
{
@Override
public boolean accept( GraphDatabaseService item )
{
return item instanceof HighlyAvailableGraphDatabase && ((HighlyAvailableGraphDatabase) item).isMaster();
}
};
@Rule
public ClusterRule clusterRule = new ClusterRule( getClass() );
private final String key = "key";
private final Label label = label( "label" );
private Map<Object, Node> createSomeData( GraphDatabaseService db )
{
try ( Transaction tx = db.beginTx() )
{
Map<Object, Node> result = new HashMap<>();
for ( int i = 0; i < 10; i++ )
{
Node node = db.createNode( label );
Object propertyValue = i;
node.setProperty( key, propertyValue );
result.put( propertyValue, node );
}
tx.success();
return result;
}
}
private IndexDefinition createIndex( GraphDatabaseService db )
{
try ( Transaction tx = db.beginTx() )
{
IndexDefinition index = db.schema().indexFor( label ).on( key ).create();
tx.success();
return index;
}
}
private static void awaitIndexOnline( IndexDefinition index, ManagedCluster cluster,
Map<Object, Node> expectedDdata ) throws InterruptedException
{
for ( GraphDatabaseService db : cluster.getAllMembers() )
{
awaitIndexOnline( index, db, expectedDdata );
}
}
private static IndexDefinition reHomedIndexDefinition( GraphDatabaseService db, IndexDefinition definition )
{
for ( IndexDefinition candidate : db.schema().getIndexes() )
{
if ( candidate.equals( definition ) )
{
return candidate;
}
}
throw new NoSuchElementException( "New database doesn't have requested index" );
}
private static void awaitIndexOnline( IndexDefinition requestedIndex, GraphDatabaseService db,
Map<Object, Node> expectedData ) throws InterruptedException
{
try ( Transaction tx = db.beginTx() )
{
IndexDefinition index = reHomedIndexDefinition( db, requestedIndex );
long timeout = System.currentTimeMillis() + SECONDS.toMillis( 120 );
while( !indexOnline( index, db ) )
{
Thread.sleep( 1 );
if ( System.currentTimeMillis() > timeout )
{
fail( "Expected index to come online within a reasonable time." );
}
}
assertIndexContents( index, db, expectedData );
tx.success();
}
}
private static void assertIndexContents( IndexDefinition index, GraphDatabaseService db,
Map<Object, Node> expectedData )
{
for ( Map.Entry<Object, Node> entry : expectedData.entrySet() )
{
assertEquals( asSet( entry.getValue() ),
asUniqueSet( db.findNodesByLabelAndProperty( index.getLabel(),
single( index.getPropertyKeys() ), entry.getKey() ) ) );
}
}
private static boolean indexOnline( IndexDefinition index, GraphDatabaseService db )
{
try
{
return db.schema().getIndexState( index ) == IndexState.ONLINE;
}
catch ( NotFoundException e )
{
return false;
}
}
private static class ControlledIndexPopulator implements IndexPopulator
{
private final DoubleLatch latch;
private final IndexPopulator delegate;
public ControlledIndexPopulator( IndexPopulator delegate, DoubleLatch latch )
{
this.delegate = delegate;
this.latch = latch;
}
@Override
public void create() throws IOException
{
delegate.create();
}
@Override
public void drop() throws IOException
{
delegate.drop();
}
@Override
public void add( long nodeId, Object propertyValue ) throws IndexEntryConflictException, IOException
{
delegate.add(nodeId, propertyValue);
latch.startAndAwaitFinish();
}
@Override
public void verifyDeferredConstraints( PropertyAccessor propertyAccessor ) throws Exception
{
delegate.verifyDeferredConstraints( propertyAccessor );
}
@Override
public IndexUpdater newPopulatingUpdater( PropertyAccessor propertyAccessor ) throws IOException
{
return delegate.newPopulatingUpdater( propertyAccessor );
}
@Override
public void close( boolean populationCompletedSuccessfully ) throws IOException
{
delegate.close(populationCompletedSuccessfully);
assertTrue( "Expected population to succeed :(", populationCompletedSuccessfully );
latch.finish();
}
@Override
public void markAsFailed( String failure ) throws IOException
{
delegate.markAsFailed( failure );
}
}
public static final SchemaIndexProvider.Descriptor CONTROLLED_PROVIDER_DESCRIPTOR =
new SchemaIndexProvider.Descriptor( "controlled", "1.0" );
private static class ControlledSchemaIndexProvider extends SchemaIndexProvider
{
private final SchemaIndexProvider delegate;
private final DoubleLatch latch = new DoubleLatch();
public ControlledSchemaIndexProvider(SchemaIndexProvider delegate)
{
super( CONTROLLED_PROVIDER_DESCRIPTOR, 100 /*we want it to always win*/ );
this.delegate = delegate;
}
@Override
public IndexPopulator getPopulator( long indexId, IndexDescriptor descriptor, IndexConfiguration config )
{
return new ControlledIndexPopulator( delegate.getPopulator( indexId, descriptor, config ), latch );
}
@Override
public IndexAccessor getOnlineAccessor( long indexId, IndexConfiguration config ) throws IOException
{
return delegate.getOnlineAccessor(indexId, config);
}
@Override
public InternalIndexState getInitialState( long indexId )
{
return delegate.getInitialState(indexId);
}
@Override
public String getPopulationFailure( long indexId ) throws IllegalStateException
{
return delegate.getPopulationFailure( indexId );
}
}
interface IndexProviderDependencies
{
GraphDatabaseService db();
Config config();
}
public static class ControllingIndexProviderFactory extends KernelExtensionFactory<IndexProviderDependencies>
{
private final Map<GraphDatabaseService, SchemaIndexProvider> perDbIndexProvider;
private final Predicate<GraphDatabaseService> injectLatchPredicate;
public ControllingIndexProviderFactory( Map<GraphDatabaseService, SchemaIndexProvider> perDbIndexProvider,
Predicate<GraphDatabaseService> injectLatchPredicate)
{
super( CONTROLLED_PROVIDER_DESCRIPTOR.getKey() );
this.perDbIndexProvider = perDbIndexProvider;
this.injectLatchPredicate = injectLatchPredicate;
}
@Override
public Lifecycle newKernelExtension( SchemaIndexHaIT.IndexProviderDependencies deps ) throws Throwable
{
if(injectLatchPredicate.accept( deps.db() ))
{
ControlledSchemaIndexProvider provider = new ControlledSchemaIndexProvider(
new LuceneSchemaIndexProvider( DirectoryFactory.PERSISTENT, deps.config() ) );
perDbIndexProvider.put( deps.db(), provider );
return provider;
}
else
{
return new LuceneSchemaIndexProvider( DirectoryFactory.PERSISTENT, deps.config() );
}
}
}
private static class ControlledGraphDatabaseFactory extends HighlyAvailableGraphDatabaseFactory
{
final Map<GraphDatabaseService,SchemaIndexProvider> perDbIndexProvider = new ConcurrentHashMap<>();
private final KernelExtensionFactory<?> factory;
public ControlledGraphDatabaseFactory()
{
factory = new ControllingIndexProviderFactory(perDbIndexProvider, Predicates.<GraphDatabaseService>TRUE());
}
private ControlledGraphDatabaseFactory( Predicate<GraphDatabaseService> dbsToControlIndexingOn )
{
factory = new ControllingIndexProviderFactory(perDbIndexProvider, dbsToControlIndexingOn);
}
@Override
public GraphDatabaseBuilder newHighlyAvailableDatabaseBuilder(String path)
{
getCurrentState().addKernelExtensions( Arrays.<KernelExtensionFactory<?>>asList( factory ) );
return super.newHighlyAvailableDatabaseBuilder( path );
}
void awaitPopulationStarted( GraphDatabaseService db )
{
ControlledSchemaIndexProvider provider = (ControlledSchemaIndexProvider) perDbIndexProvider.get( db );
if(provider != null ) provider.latch.awaitStart();
}
void triggerFinish( GraphDatabaseService db )
{
ControlledSchemaIndexProvider provider = (ControlledSchemaIndexProvider) perDbIndexProvider.get( db );
if(provider != null ) provider.latch.finish();
}
}
}
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_api_SchemaIndexHaIT.java
|
5,639
|
public class KernelTransactionImplementationTest
{
private AbstractTransactionManager txm = mock( AbstractTransactionManager.class );
@Test
public void shouldBeAbleToRollbackPreparedTransaction() throws Exception
{
// given
KernelTransactionImplementation tx = new KernelTransactionImplementation( null, null, false, null, null,
null, txm, null, null, mock(LockHolder.class), null, null, mock( NeoStore.class ),
mock(TransactionState.class) );
// when
tx.prepare();
// then (no exception)
tx.rollback();
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_api_KernelTransactionImplementationTest.java
|
5,640
|
public class KernelTransactionFactory
{
static KernelTransaction kernelTransaction()
{
PersistenceManager pm = mock( PersistenceManager.class );
when( pm.getResource() ).thenReturn( mock( ResourceHolder.class ) );
return new KernelTransactionImplementation( mock( StatementOperationParts.class ),
mock( LegacyKernelOperations.class ) , false, mock( SchemaWriteGuard.class ), null, null,
mock( AbstractTransactionManager.class ), null, null, null, pm,
null, mock( NeoStore.class ), null );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_api_KernelTransactionFactory.java
|
5,641
|
@Deprecated
public class Version extends Service
{
public static Version getKernel()
{
return KERNEL_VERSION;
}
public static String getKernelRevision()
{
return getKernel().getRevision();
}
private final String artifactId;
private final String title;
private final String vendor;
private final String version;
@Override
public String toString()
{
StringBuilder result = new StringBuilder();
if ( title != null )
{
result.append( title );
if ( artifactId == null || !artifactId.equals( title ) )
{
result.append( " (" ).append( artifactId ).append( ')' );
}
}
else if ( artifactId != null )
{
result.append( artifactId );
}
else
{
result.append( "Unknown Component" );
}
result.append( ", " );
if ( title == null )
{
result.append( "unpackaged " );
}
result.append( "version: " ).append( getVersion() );
return result.toString();
}
/**
* Gets the version of the running neo4j kernel.
*
* @return the version of the neo4j kernel
*/
public final String getVersion()
{
if ( version == null || version.equals( "" ) )
{
return "revision: " + getRevision();
}
else if ( version.endsWith( "-SNAPSHOT" ) )
{
return version + " (revision: " + getRevision() + ")";
}
else
{
return version;
}
}
public String getReleaseVersion()
{
return version;
}
/**
* Returns the build revision of the running neo4j kernel.
*
* @return build revision
*/
public final String getRevision()
{
StringBuilder result = new StringBuilder( getReleaseVersion() );
result.append( ':' ).append( getBranchName() ).append( ':' );
String build = getBuildNumber();
if ( !(build.startsWith( "${" ) || build.startsWith( "{" )) )
{
result.append( build ).append( '/' );
}
result.append( getCommitId() );
if ( getCommitDescription().endsWith( "-dirty" ) )
{
result.append( "-dirty" );
}
return result.toString();
}
protected String getCommitDescription()
{
return "{CommitDescription}";
}
protected String getBuildNumber()
{
return "{BuildNumber}";
}
protected String getCommitId()
{
return "{CommitId}";
}
protected String getBranchName()
{
return "{BranchName}";
}
protected Version( String artifactId, String version )
{
super( artifactId );
this.artifactId = artifactId;
Package pkg = getClass().getPackage();
this.title = defaultValue( pkg.getImplementationTitle(), artifactId );
this.vendor = defaultValue( pkg.getImplementationVendor(), "Neo Technology" );
this.version = defaultValue( pkg.getImplementationVersion(), version );
}
private static String defaultValue( String preferred, String fallback )
{
return (preferred == null || preferred.equals( "" )) ? fallback : preferred;
}
/**
* A very nice to have main-method for quickly checking the version of a neo4j kernel,
* for example given a kernel jar file.
*/
public static void main( String[] args )
{
Version kernelVersion = getKernel();
System.out.println( kernelVersion );
System.out.println( "Title: " + kernelVersion.title );
System.out.println( "Vendor: " + kernelVersion.vendor );
System.out.println( "ArtifactId: " + kernelVersion.artifactId );
System.out.println( "Version: " + kernelVersion.getVersion() );
System.out.println( "ReleaseVersion: " + kernelVersion.getReleaseVersion() );
System.out.println( "Revision: " + kernelVersion.getRevision() );
System.out.println( "CommitDescription: " + kernelVersion.getCommitDescription() );
System.out.println( "BuildNumber: " + kernelVersion.getBuildNumber() );
System.out.println( "BranchName: " + kernelVersion.getBranchName() );
System.out.println( "CommitId: " + kernelVersion.getCommitId() );
}
static final String KERNEL_ARTIFACT_ID = "neo4j-kernel";
private static final Version KERNEL_VERSION;
static
{
Version kernelVersion;
try
{
kernelVersion = Service.load( Version.class, KERNEL_ARTIFACT_ID );
}
catch ( NoSuchElementException ex )
{
kernelVersion = null;
}
if ( kernelVersion == null )
{
try
{
kernelVersion = (Version) Class.forName( "org.neo4j.kernel.impl.ComponentVersion" ).newInstance();
}
catch ( Exception e )
{
kernelVersion = null;
}
}
if ( kernelVersion == null )
{
kernelVersion = new Version( KERNEL_ARTIFACT_ID, "" );
}
KERNEL_VERSION = kernelVersion;
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_Version.java
|
5,642
|
NONE
{
public UniquenessFilter create( Object optionalParameter )
{
return org.neo4j.graphdb.traversal.Uniqueness.NONE.create(optionalParameter);
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_Uniqueness.java
|
5,643
|
RELATIONSHIP_LEVEL
{
@Override
public UniquenessFilter create( Object optionalParameter )
{
return org.neo4j.graphdb.traversal.Uniqueness.RELATIONSHIP_LEVEL.create(optionalParameter);
}
},
| false
|
community_kernel_src_main_java_org_neo4j_kernel_Uniqueness.java
|
5,644
|
RELATIONSHIP_RECENT
{
public UniquenessFilter create( Object optionalParameter )
{
return org.neo4j.graphdb.traversal.Uniqueness.RELATIONSHIP_RECENT.create(optionalParameter);
}
},
| false
|
community_kernel_src_main_java_org_neo4j_kernel_Uniqueness.java
|
5,645
|
RELATIONSHIP_PATH
{
public UniquenessFilter create( Object optionalParameter )
{
return org.neo4j.graphdb.traversal.Uniqueness.RELATIONSHIP_PATH.create(optionalParameter);
}
},
| false
|
community_kernel_src_main_java_org_neo4j_kernel_Uniqueness.java
|
5,646
|
RELATIONSHIP_GLOBAL
{
public UniquenessFilter create( Object optionalParameter )
{
return org.neo4j.graphdb.traversal.Uniqueness.RELATIONSHIP_GLOBAL.create(optionalParameter);
}
},
| false
|
community_kernel_src_main_java_org_neo4j_kernel_Uniqueness.java
|
5,647
|
public class UniquenessConstraint
{
private final int labelId;
private final int propertyKeyId;
public UniquenessConstraint( int labelId, int propertyKeyId )
{
this.labelId = labelId;
this.propertyKeyId = propertyKeyId;
}
@Override
public boolean equals( Object obj )
{
if ( this == obj )
{
return true;
}
if ( obj != null && getClass() == obj.getClass() )
{
UniquenessConstraint that = (UniquenessConstraint) obj;
return this.equals( that.labelId, that.propertyKeyId );
}
return false;
}
@Override
public int hashCode()
{
int result = labelId;
result = 31 * result + propertyKeyId;
return result;
}
public int label()
{
return labelId;
}
public int propertyKeyId()
{
return propertyKeyId;
}
public boolean equals( int labelId, int propertyKeyId )
{
return this.labelId == labelId && this.propertyKeyId == propertyKeyId;
}
@Override
public String toString()
{
return String.format( "CONSTRAINT ON ( n:label[%s] ) ASSERT n.property[%s] IS UNIQUE", labelId, propertyKeyId );
}
public String userDescription( TokenNameLookup tokenNameLookup )
{
String labelName = tokenNameLookup.labelGetName( labelId );
String boundIdentifier = labelName.toLowerCase();
return String.format( "CONSTRAINT ON ( %s:%s ) ASSERT %s.%s IS UNIQUE", boundIdentifier, labelName,
boundIdentifier, tokenNameLookup.propertyKeyGetName( propertyKeyId ) );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_constraints_UniquenessConstraint.java
|
5,648
|
{
@Override
public long maxCount()
{
return 0;
}
@Override public void close() throws IOException
{
}
@Override public Iterator<Long> iterator()
{
return emptyIterator();
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_direct_BoundedIterable.java
|
5,649
|
OUTGOING( Direction.INCOMING )
{
@Override
Exclusion reversed()
{
return INCOMING;
}
},
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StandardExpander.java
|
5,650
|
public class DirectStoreAccess implements Closeable
{
private final StoreAccess nativeStores;
private final LabelScanStore labelScanStore;
private final SchemaIndexProvider indexes;
public DirectStoreAccess(
StoreAccess nativeStores, LabelScanStore labelScanStore, SchemaIndexProvider indexes )
{
this.nativeStores = nativeStores;
this.labelScanStore = labelScanStore;
this.indexes = indexes;
}
public StoreAccess nativeStores()
{
return nativeStores;
}
public LabelScanStore labelScanStore()
{
return labelScanStore;
}
public SchemaIndexProvider indexes()
{
return indexes;
}
@Override
public void close() throws IOException
{
nativeStores.close();
labelScanStore.shutdown();
try
{
indexes.shutdown();
}
catch ( Throwable throwable )
{
throw new IOException( throwable );
}
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_direct_DirectStoreAccess.java
|
5,651
|
public abstract class FlipFailedKernelException extends KernelException
{
public FlipFailedKernelException( Throwable cause, String message, Object... parameters )
{
super( Status.Schema.IndexCreationFailure, cause, message, parameters );
}
public FlipFailedKernelException( String message, Object... parameters )
{
super( Status.Schema.IndexCreationFailure, message, parameters );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_exceptions_index_FlipFailedKernelException.java
|
5,652
|
public final class ExceptionDuringFlipKernelException extends FlipFailedKernelException
{
public ExceptionDuringFlipKernelException( Throwable cause )
{
super( cause, "Failed to transition index to new context: %s", cause.getMessage() );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_exceptions_index_ExceptionDuringFlipKernelException.java
|
5,653
|
public abstract class TransactionalException extends Exception
{
TransactionalException( Exception cause )
{
super( cause );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_exceptions_TransactionalException.java
|
5,654
|
public class TransactionForcefullyRolledBackException extends TransactionFailureException
{
public TransactionForcefullyRolledBackException( RuntimeException cause )
{
super( cause );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_exceptions_TransactionForcefullyRolledBackException.java
|
5,655
|
public class TransactionFailureException extends TransactionalException
{
private static final int NO_CODE = 0;
private final int errorCode;
public TransactionFailureException( HeuristicMixedException cause )
{
super( cause );
errorCode = XAException.XA_HEURMIX;
}
public TransactionFailureException( HeuristicRollbackException cause )
{
super( cause );
errorCode = XAException.XA_HEURRB;
}
public TransactionFailureException( RollbackException cause )
{
super( cause );
errorCode = XAException.XA_RBROLLBACK;
}
public TransactionFailureException( SystemException cause )
{
super( cause );
errorCode = XAException.XAER_RMERR;
}
public TransactionFailureException( Exception e )
{
super(e);
errorCode = NO_CODE;
}
public RuntimeException unBoxedForCommit() throws XAException
{
Throwable cause = getCause();
if ( errorCode == NO_CODE)
{
return (cause instanceof RuntimeException)? (RuntimeException) cause : new RuntimeException( cause );
}
throw withCause( new XAException( errorCode ), cause );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_exceptions_TransactionFailureException.java
|
5,656
|
class Code
{
public static Collection<Status> all()
{
Collection<Status> result = new ArrayList<>();
for ( Class<?> child : Status.class.getDeclaredClasses() )
{
if ( child.isEnum() && Status.class.isAssignableFrom( child ) )
{
@SuppressWarnings("unchecked")
Class<? extends Status> statusType = (Class<? extends Status>) child;
Collections.addAll( result, statusType.getEnumConstants() );
}
}
return result;
}
private final Classification classification;
private final String description;
private final String category;
private final String title;
<C extends Enum<C> & Status> Code( Classification classification, C categoryAndTitle, String description )
{
this.classification = classification;
this.category = categoryAndTitle.getDeclaringClass().getSimpleName();
this.title = categoryAndTitle.name();
this.description = description;
}
/**
* The portable, serialized status code. This will always be in the format:
*
* <pre>
* Neo.[Classification].[Category].[Title]
* </pre>
* @return
*/
public final String serialize()
{
return format( "Neo.%s.%s.%s", classification, category, title );
}
public final String description()
{
return description;
}
public Classification classification()
{
return classification;
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
Code code = (Code) o;
if ( !category.equals( code.category ) )
{
return false;
}
if ( classification != code.classification )
{
return false;
}
if ( !title.equals( code.title ) )
{
return false;
}
return true;
}
@Override
public int hashCode()
{
int result = classification.hashCode();
result = 31 * result + category.hashCode();
result = 31 * result + title.hashCode();
return result;
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_exceptions_Status.java
|
5,657
|
public class ReleaseLocksFailedKernelException extends KernelException
{
public ReleaseLocksFailedKernelException( String msg, Exception releaseException )
{
super(Status.Transaction.ReleaseLocksFailed, releaseException, msg);
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_exceptions_ReleaseLocksFailedKernelException.java
|
5,658
|
public class RelationshipTypeIdNotFoundKernelException extends KernelException
{
public RelationshipTypeIdNotFoundKernelException( long relationshipTypeId, Exception cause )
{
super( Status.Schema.NoSuchRelationshipType, cause, "Relationship type id '%s' not found", relationshipTypeId );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_exceptions_RelationshipTypeIdNotFoundKernelException.java
|
5,659
|
public class ReadOnlyDatabaseKernelException extends KernelException
{
public ReadOnlyDatabaseKernelException()
{
super( Status.General.ReadOnly, (Throwable) null, "Cannot modify a read-only database" );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_exceptions_ReadOnlyDatabaseKernelException.java
|
5,660
|
public class PropertyNotFoundException extends KernelException
{
private final String entity;
private final int propertyKeyId;
public PropertyNotFoundException( int propertyKeyId, EntityType entityType, long entityId )
{
this( entityType == EntityType.GRAPH ? "GraphProperties" : entityType.name() + "[" + entityId + "]",
propertyKeyId );
}
private PropertyNotFoundException( String entity, int propertyKeyId )
{
super( Status.Statement.NoSuchProperty, "%s has no property with propertyKeyId=%s.", entity, propertyKeyId );
this.entity = entity;
this.propertyKeyId = propertyKeyId;
}
@Override
public String getUserMessage( TokenNameLookup tokenNameLookup )
{
return format( "%s has no property with propertyKey=\"%s\".", entity,
tokenNameLookup.propertyKeyGetName( propertyKeyId ) );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_exceptions_PropertyNotFoundException.java
|
5,661
|
public class PropertyKeyNotFoundException extends KernelException
{
public PropertyKeyNotFoundException( String propertyKey, Exception cause )
{
super( Status.Schema.NoSuchPropertyKey, cause, "Property key '" + propertyKey + "' not found" );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_exceptions_PropertyKeyNotFoundException.java
|
5,662
|
public class PropertyKeyIdNotFoundKernelException extends KernelException
{
public PropertyKeyIdNotFoundKernelException( int propertyKeyId, Exception cause )
{
super( Status.Schema.NoSuchPropertyKey, cause, "Property key id '%s' not found", propertyKeyId );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_exceptions_PropertyKeyIdNotFoundKernelException.java
|
5,663
|
public class LabelNotFoundKernelException extends KernelException
{
public LabelNotFoundKernelException( String message, Exception cause )
{
super( Status.Schema.NoSuchLabel, cause, message);
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_exceptions_LabelNotFoundKernelException.java
|
5,664
|
public abstract class KernelException extends Exception
{
private final Status statusCode;
protected KernelException( Status statusCode, Throwable cause, String message, Object... parameters )
{
super( String.format( message, parameters ) );;
this.statusCode = statusCode;
initCause( cause );
}
protected KernelException( Status statusCode, String message, Object... parameters )
{
super( String.format( message, parameters ) );;
this.statusCode = statusCode;
}
/** The Neo4j status code associated with this exception type. */
public Status status()
{
return statusCode;
}
public String getUserMessage( TokenNameLookup tokenNameLookup )
{
return getMessage();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_exceptions_KernelException.java
|
5,665
|
public class InvalidTransactionTypeKernelException extends KernelException
{
public InvalidTransactionTypeKernelException(String message)
{
super( Status.Transaction.InvalidType, (Throwable) null, message );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_exceptions_InvalidTransactionTypeKernelException.java
|
5,666
|
public class EntityNotFoundException extends KernelException
{
public EntityNotFoundException( EntityType entityType, long entityId, Throwable cause )
{
super( Status.Statement.EntityNotFound, cause, "Unable to load %s with id %s.", entityType.name(), entityId );
}
public EntityNotFoundException( EntityType entityType, long entityId )
{
super( Status.Statement.EntityNotFound, "Unable to load %s with id %s.", entityType.name(), entityId );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_exceptions_EntityNotFoundException.java
|
5,667
|
public class ConstraintCreationException extends RuntimeException
{
public ConstraintCreationException( CreateConstraintFailureException cause )
{
super( cause );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_exceptions_ConstraintCreationException.java
|
5,668
|
public class BeginTransactionFailureException extends TransactionalException
{
public BeginTransactionFailureException( Exception cause )
{
super( cause );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_exceptions_BeginTransactionFailureException.java
|
5,669
|
public class StatusTest
{
@Test
public void eachStatusCodeHasAUniqueCode() throws Exception
{
// given
Set<Object> codes = new HashSet<>();
// when
for ( Status status : Status.Code.all() )
{
codes.add( status.code().serialize() );
}
// then
assertNotEquals( 0, codes.size() );
assertEquals( Status.Code.all().size(), codes.size() );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_api_exception_StatusTest.java
|
5,670
|
NODE_LEVEL
{
@Override
public UniquenessFilter create( Object optionalParameter )
{
return org.neo4j.graphdb.traversal.Uniqueness.NODE_LEVEL.create(optionalParameter);
}
},
| false
|
community_kernel_src_main_java_org_neo4j_kernel_Uniqueness.java
|
5,671
|
NODE_RECENT
{
public UniquenessFilter create( Object optionalParameter )
{
return org.neo4j.graphdb.traversal.Uniqueness.NODE_RECENT.create(optionalParameter);
}
},
| false
|
community_kernel_src_main_java_org_neo4j_kernel_Uniqueness.java
|
5,672
|
NODE_PATH
{
public UniquenessFilter create( Object optionalParameter )
{
return org.neo4j.graphdb.traversal.Uniqueness.NODE_PATH.create(optionalParameter);
}
},
| false
|
community_kernel_src_main_java_org_neo4j_kernel_Uniqueness.java
|
5,673
|
NODE_GLOBAL
{
public UniquenessFilter create( Object optionalParameter )
{
return org.neo4j.graphdb.traversal.Uniqueness.NODE_GLOBAL.create(optionalParameter);
}
},
| false
|
community_kernel_src_main_java_org_neo4j_kernel_Uniqueness.java
|
5,674
|
@Deprecated
public class StoreLocker
{
public static final String STORE_LOCK_FILENAME = "store_lock";
private final FileSystemAbstraction fileSystemAbstraction;
private FileLock storeLockFileLock;
private StoreChannel storeLockFileChannel;
public StoreLocker( FileSystemAbstraction fileSystemAbstraction )
{
this.fileSystemAbstraction = fileSystemAbstraction;
}
/**
* Obtains lock on store file so that we can ensure the store is not shared between database instances
* <p/>
* Creates store dir if necessary, creates store lock file if necessary
*
* @throws StoreLockException if lock could not be acquired
*/
public void checkLock( File storeDir ) throws StoreLockException
{
File storeLockFile = new File( storeDir, STORE_LOCK_FILENAME );
try
{
if ( !fileSystemAbstraction.fileExists( storeLockFile ) )
{
fileSystemAbstraction.mkdirs( storeLockFile.getParentFile() );
}
}
catch ( IOException e )
{
throw new StoreLockException( "Unable to create path for store dir: " + storeDir+". Please ensure no other process is using this database, and that the directory is writable (required even for read-only access)", e );
}
try
{
storeLockFileChannel = fileSystemAbstraction.open( storeLockFile, "rw" );
storeLockFileLock = fileSystemAbstraction.tryLock( storeLockFile, storeLockFileChannel );
}
catch ( OverlappingFileLockException e )
{
throw new StoreLockException( "Unable to obtain lock on store lock file: " + storeLockFile+". Please ensure no other process is using this database, and that the directory is writable (required even for read-only access)", e );
}
catch ( IOException e )
{
throw new StoreLockException( "Unable to obtain lock on store lock file: " + storeLockFile+". Please ensure no other process is using this database, and that the directory is writable (required even for read-only access)", e );
}
}
public void release() throws IOException
{
if ( storeLockFileLock != null )
{
storeLockFileLock.release();
storeLockFileLock = null;
}
if ( storeLockFileChannel != null )
{
storeLockFileChannel.close();
storeLockFileChannel = null;
}
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StoreLocker.java
|
5,675
|
public class StoreLockException extends RuntimeException
{
public StoreLockException( String msg )
{
super( msg );
}
public StoreLockException( String msg, Throwable t )
{
super( msg, t );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StoreLockException.java
|
5,676
|
private static final class WrappingRelationshipExpander extends StandardExpander
{
private static final String IMMUTABLE = "Immutable Expander ";
private final RelationshipExpander expander;
WrappingRelationshipExpander( RelationshipExpander expander )
{
this.expander = expander;
}
@Override
void buildString( StringBuilder result )
{
result.append( expander );
}
@Override
Iterator<Relationship> doExpand( Path path, BranchState state )
{
return expander.expand( path.endNode() ).iterator();
}
@Override
public StandardExpander add( RelationshipType type, Direction direction )
{
throw new UnsupportedOperationException( IMMUTABLE + expander );
}
@Override
public StandardExpander remove( RelationshipType type )
{
throw new UnsupportedOperationException( IMMUTABLE + expander );
}
@Override
public StandardExpander reversed()
{
return reverse();
}
@Override
public StandardExpander reverse()
{
throw new UnsupportedOperationException( IMMUTABLE + expander );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StandardExpander.java
|
5,677
|
private static final class WrappingExpander extends StandardExpander
{
private static final String IMMUTABLE = "Immutable Expander ";
private final PathExpander expander;
WrappingExpander( PathExpander expander )
{
this.expander = expander;
}
@Override
void buildString( StringBuilder result )
{
result.append( expander );
}
@Override
Iterator<Relationship> doExpand( Path path, BranchState state )
{
return expander.expand( path, state ).iterator();
}
@Override
public StandardExpander add( RelationshipType type, Direction direction )
{
throw new UnsupportedOperationException( IMMUTABLE + expander );
}
@Override
public StandardExpander remove( RelationshipType type )
{
throw new UnsupportedOperationException( IMMUTABLE + expander );
}
@Override
public StandardExpander reversed()
{
return reverse();
}
@Override
public StandardExpander reverse()
{
throw new UnsupportedOperationException( IMMUTABLE + expander );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StandardExpander.java
|
5,678
|
static abstract class StandardExpansion<T> implements Expansion<T>
{
final StandardExpander expander;
final Path path;
final BranchState state;
StandardExpansion( StandardExpander expander, Path path, BranchState state )
{
this.expander = expander;
this.path = path;
this.state = state;
}
String stringRepresentation( String nodesORrelationships )
{
return "Expansion[" + path + ".expand( " + expander + " )."
+ nodesORrelationships + "()]";
}
abstract StandardExpansion<T> createNew( StandardExpander expander );
public StandardExpansion<T> including( RelationshipType type )
{
return createNew( expander.add( type ) );
}
public StandardExpansion<T> including( RelationshipType type,
Direction direction )
{
return createNew( expander.add( type, direction ) );
}
public StandardExpansion<T> excluding( RelationshipType type )
{
return createNew( expander.remove( type ) );
}
public StandardExpander expander()
{
return expander;
}
public StandardExpansion<T> filterNodes( Predicate<? super Node> filter )
{
return createNew( expander.addNodeFilter( filter ) );
}
public StandardExpansion<T> filterRelationships(
Predicate<? super Relationship> filter )
{
return createNew( expander.addRelationshipFilter( filter ) );
}
public T getSingle()
{
final Iterator<T> expanded = iterator();
if ( expanded.hasNext() )
{
final T result = expanded.next();
if ( expanded.hasNext() )
{
throw new NotFoundException(
"More than one relationship found for " + this );
}
return result;
}
return null;
}
public boolean isEmpty()
{
return !expander.doExpand( path, state ).hasNext();
}
public StandardExpansion<Node> nodes()
{
return new NodeExpansion( expander, path, state );
}
public StandardExpansion<Relationship> relationships()
{
return new RelationshipExpansion( expander, path, state );
}
public StandardExpansion<Pair<Relationship, Node>> pairs()
{
return new PairExpansion( expander, path, state );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StandardExpander.java
|
5,679
|
private static final class RelationshipFilter extends Filter
{
private final Predicate<? super Relationship> predicate;
RelationshipFilter( Predicate<? super Relationship> predicate )
{
this.predicate = predicate;
}
@Override
public String toString()
{
return predicate.toString();
}
@Override
boolean exclude( Path path )
{
return !predicate.accept( path.lastRelationship() );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StandardExpander.java
|
5,680
|
private static final class RelationshipExpansion extends
StandardExpansion<Relationship>
{
RelationshipExpansion( StandardExpander expander, Path path, BranchState state )
{
super( expander, path, state );
}
@Override
public String toString()
{
return stringRepresentation( "relationships" );
}
@Override
StandardExpansion<Relationship> createNew( StandardExpander expander )
{
return new RelationshipExpansion( expander, path, state );
}
@Override
public StandardExpansion<Relationship> relationships()
{
return this;
}
public Iterator<Relationship> iterator()
{
return expander.doExpand( path, state );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StandardExpander.java
|
5,681
|
{
@Override
protected Iterator<Relationship> createNestedIterator( DirectionAndTypes item )
{
return node.getRelationships( item.direction, item.types ).iterator();
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StandardExpander.java
|
5,682
|
static class RegularExpander extends StandardExpander
{
final Map<Direction, RelationshipType[]> typesMap;
final DirectionAndTypes[] directions;
RegularExpander( Map<Direction, RelationshipType[]> types )
{
this.typesMap = types;
this.directions = new DirectionAndTypes[types.size()];
int i = 0;
for ( Map.Entry<Direction, RelationshipType[]> entry : types.entrySet() )
{
this.directions[i++] = new DirectionAndTypes( entry.getKey(), entry.getValue() );
}
}
@Override
void buildString( StringBuilder result )
{
result.append( typesMap.toString() );
}
@Override
Iterator<Relationship> doExpand( Path path, BranchState state )
{
final Node node = path.endNode();
if ( directions.length == 1 )
{
DirectionAndTypes direction = directions[0];
return node.getRelationships( direction.direction, direction.types ).iterator();
}
else
{
return new NestingIterator<Relationship, DirectionAndTypes>( new ArrayIterator<DirectionAndTypes>(
directions ) )
{
@Override
protected Iterator<Relationship> createNestedIterator( DirectionAndTypes item )
{
return node.getRelationships( item.direction, item.types ).iterator();
}
};
}
}
StandardExpander createNew( Map<Direction, RelationshipType[]> types )
{
if ( types.isEmpty() )
{
return new AllExpander( Direction.BOTH );
}
return new RegularExpander( types );
}
@Override
public StandardExpander add( RelationshipType type, Direction direction )
{
Map<Direction, Collection<RelationshipType>> tempMap = temporaryTypeMapFrom( typesMap );
tempMap.get( direction ).add( type );
return createNew( toTypeMap( tempMap ) );
}
@Override
public StandardExpander remove( RelationshipType type )
{
Map<Direction, Collection<RelationshipType>> tempMap = temporaryTypeMapFrom( typesMap );
for ( Direction direction : Direction.values() )
{
tempMap.get( direction ).remove( type );
}
return createNew( toTypeMap( tempMap ) );
}
@Override
public StandardExpander reversed()
{
return reverse();
}
@Override
public StandardExpander reverse()
{
Map<Direction, Collection<RelationshipType>> tempMap = temporaryTypeMapFrom( typesMap );
Collection<RelationshipType> out = tempMap.get( Direction.OUTGOING );
Collection<RelationshipType> in = tempMap.get( Direction.INCOMING );
tempMap.put( Direction.OUTGOING, in );
tempMap.put( Direction.INCOMING, out );
return createNew( toTypeMap( tempMap ) );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StandardExpander.java
|
5,683
|
private static final class PathFilter extends Filter
{
private final Predicate<? super Path> predicate;
PathFilter( Predicate<? super Path> predicate )
{
this.predicate = predicate;
}
@Override
public String toString()
{
return predicate.toString();
}
@Override
boolean exclude( Path path )
{
return !predicate.accept( path );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StandardExpander.java
|
5,684
|
{
@Override
protected Pair<Relationship, Node> underlyingObjectToObject(
Relationship rel )
{
return Pair.of( rel, rel.getOtherNode( node ) );
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StandardExpander.java
|
5,685
|
private static final class PairExpansion extends
StandardExpansion<Pair<Relationship, Node>>
{
PairExpansion( StandardExpander expander, Path path, BranchState state )
{
super( expander, path, state );
}
@Override
public String toString()
{
return stringRepresentation( "pairs" );
}
@Override
StandardExpansion<Pair<Relationship, Node>> createNew( StandardExpander expander )
{
return new PairExpansion( expander, path, state );
}
@Override
public StandardExpansion<Pair<Relationship, Node>> pairs()
{
return this;
}
public Iterator<Pair<Relationship, Node>> iterator()
{
final Node node = path.endNode();
return new IteratorWrapper<Pair<Relationship, Node>, Relationship>(
expander.doExpand( path, state ) )
{
@Override
protected Pair<Relationship, Node> underlyingObjectToObject(
Relationship rel )
{
return Pair.of( rel, rel.getOtherNode( node ) );
}
};
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StandardExpander.java
|
5,686
|
private static final class NodeFilter extends Filter
{
private final Predicate<? super Node> predicate;
NodeFilter( Predicate<? super Node> predicate )
{
this.predicate = predicate;
}
@Override
public String toString()
{
return predicate.toString();
}
@Override
boolean exclude( Path path )
{
return !predicate.accept( path.lastRelationship().getOtherNode( path.endNode() ) );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StandardExpander.java
|
5,687
|
{
@Override
protected Node underlyingObjectToObject( Relationship rel )
{
return rel.getOtherNode( node );
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StandardExpander.java
|
5,688
|
private static final class NodeExpansion extends StandardExpansion<Node>
{
NodeExpansion( StandardExpander expander, Path path, BranchState state )
{
super( expander, path, state );
}
@Override
public String toString()
{
return stringRepresentation( "nodes" );
}
@Override
StandardExpansion<Node> createNew( StandardExpander expander )
{
return new NodeExpansion( expander, path, state );
}
@Override
public StandardExpansion<Node> nodes()
{
return this;
}
public Iterator<Node> iterator()
{
final Node node = path.endNode();
return new IteratorWrapper<Node, Relationship>(
expander.doExpand( path, state ) )
{
@Override
protected Node underlyingObjectToObject( Relationship rel )
{
return rel.getOtherNode( node );
}
};
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StandardExpander.java
|
5,689
|
{
public boolean accept( Relationship item )
{
Path extendedPath = extend( path, item );
for ( Filter filter : filters )
{
if ( filter.exclude( extendedPath ) )
{
return false;
}
}
return true;
}
} );
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StandardExpander.java
|
5,690
|
private static final class FilteringExpander extends StandardExpander
{
private final StandardExpander expander;
private final Filter[] filters;
FilteringExpander( StandardExpander expander, Filter... filters )
{
this.expander = expander;
this.filters = filters;
}
@Override
void buildString( StringBuilder result )
{
expander.buildString( result );
result.append( "; filter:" );
for ( Filter filter : filters )
{
result.append( " " );
result.append( filter );
}
}
@Override
Iterator<Relationship> doExpand( final Path path, BranchState state )
{
return new FilteringIterator<Relationship>(
expander.doExpand( path, state ), new Predicate<Relationship>()
{
public boolean accept( Relationship item )
{
Path extendedPath = extend( path, item );
for ( Filter filter : filters )
{
if ( filter.exclude( extendedPath ) )
{
return false;
}
}
return true;
}
} );
}
@Override
public StandardExpander addNodeFilter( Predicate<? super Node> filter )
{
return new FilteringExpander( expander, append( filters,
new NodeFilter( filter ) ) );
}
@Override
public StandardExpander addRelationshipFilter(
Predicate<? super Relationship> filter )
{
return new FilteringExpander( expander, append( filters,
new RelationshipFilter( filter ) ) );
}
@Override
public StandardExpander add( RelationshipType type, Direction direction )
{
return new FilteringExpander( expander.add( type, direction ),
filters );
}
@Override
public StandardExpander remove( RelationshipType type )
{
return new FilteringExpander( expander.remove( type ), filters );
}
@Override
public StandardExpander reversed()
{
return reverse();
}
@Override
public StandardExpander reverse()
{
return new FilteringExpander( expander.reversed(), filters );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StandardExpander.java
|
5,691
|
private static abstract class Filter
{
abstract boolean exclude( Path path );
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StandardExpander.java
|
5,692
|
NONE( Direction.BOTH, "" )
{
@Override
boolean includes( Direction direction )
{
return true;
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StandardExpander.java
|
5,693
|
@Deprecated
public class StoreLockerLifecycleAdapter extends LifecycleAdapter
{
private final StoreLocker storeLocker;
private final File storeDir;
public StoreLockerLifecycleAdapter( StoreLocker storeLocker, File storeDir )
{
this.storeLocker = storeLocker;
this.storeDir = storeDir;
}
@Override
public void start() throws Throwable
{
storeLocker.checkLock( storeDir );
}
@Override
public void stop() throws Throwable
{
storeLocker.release();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_StoreLockerLifecycleAdapter.java
|
5,694
|
public class StoreLockerLifecycleAdapterTest
{
@Rule public TestName testName = new TestName();
private String storeDir;
@Before
public void before()
{
storeDir = TargetDirectory.forTest( getClass() ).cleanDirectory( testName.getMethodName() ).getAbsolutePath();
}
@Test
public void shouldAllowDatabasesToUseFilesetsSequentially() throws Exception
{
new GraphDatabaseFactory().newEmbeddedDatabase( storeDir ).shutdown();
new GraphDatabaseFactory().newEmbeddedDatabase( storeDir ).shutdown();
}
@Test
public void shouldNotAllowDatabasesToUseFilesetsConcurrently() throws Exception
{
GraphDatabaseService db = new GraphDatabaseFactory().newEmbeddedDatabase( storeDir );
try
{
new GraphDatabaseFactory().newEmbeddedDatabase( storeDir );
fail();
}
catch ( RuntimeException e )
{
assertThat( e.getCause().getCause(), instanceOf( StoreLockException.class ) );
}
finally
{
db.shutdown();
}
}
@Test
public void shouldNotAllowDatabasesToUseFilesetsConcurrentlyEvenIfTheyAreInReadOnlyMode() throws Exception
{
GraphDatabaseService db = new GraphDatabaseFactory().newEmbeddedDatabase( storeDir );
try
{
new GraphDatabaseFactory().newEmbeddedDatabaseBuilder( storeDir).
setConfig( GraphDatabaseSettings.read_only, Settings.TRUE ).
newGraphDatabase();
fail();
}
catch ( RuntimeException e )
{
assertThat( e.getCause().getCause(), instanceOf( StoreLockException.class ) );
}
finally
{
db.shutdown();
}
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_StoreLockerLifecycleAdapterTest.java
|
5,695
|
public class StoreLockerTest
{
private static final TargetDirectory target = TargetDirectory.forTest( StoreLockerTest.class );
@Test
public void shouldObtainLockWhenStoreFileNotLocked() throws Exception
{
FileSystemAbstraction fileSystemAbstraction = new CannedFileSystemAbstraction( true, null, null, true, NOTHING );
StoreLocker storeLocker = new StoreLocker( fileSystemAbstraction );
try
{
storeLocker.checkLock( target.cleanDirectory( "unused" ) );
// Ok
}
catch ( StoreLockException e )
{
fail();
}
}
@Test
public void shouldCreateStoreDirAndObtainLockWhenStoreDirDoesNotExist() throws Exception
{
FileSystemAbstraction fileSystemAbstraction = new CannedFileSystemAbstraction( false, null, null, true, NOTHING );
StoreLocker storeLocker = new StoreLocker( fileSystemAbstraction );
try
{
storeLocker.checkLock( target.cleanDirectory( "unused" ) );
// Ok
}
catch ( StoreLockException e )
{
fail();
}
}
@Test
public void shouldNotObtainLockWhenStoreDirCannotBeCreated() throws Exception
{
FileSystemAbstraction fileSystemAbstraction = new CannedFileSystemAbstraction( false,
new IOException( "store dir could not be created" ), null, true, NOTHING );
StoreLocker storeLocker = new StoreLocker( fileSystemAbstraction );
File storeDir = target.cleanDirectory( "unused" );
try
{
storeLocker.checkLock( storeDir );
fail();
}
catch ( StoreLockException e )
{
String msg = format( "Unable to create path for store dir: %s. Please ensure no other process is using this database, and that the directory is writable (required even for read-only access)", storeDir );
assertThat( e.getMessage(), is( msg ) );
}
}
@Test
public void shouldNotObtainLockWhenUnableToOpenLockFile() throws Exception
{
FileSystemAbstraction fileSystemAbstraction = new CannedFileSystemAbstraction( true, null,
new IOException( "cannot open lock file" ), true, NOTHING );
StoreLocker storeLocker = new StoreLocker( fileSystemAbstraction );
File storeDir = target.cleanDirectory( "unused" );
try
{
storeLocker.checkLock( storeDir );
fail();
}
catch ( StoreLockException e )
{
String msg = format( "Unable to obtain lock on store lock file: %s. Please ensure no other process is using this database, and that the directory is writable (required even for read-only access)", new File( storeDir,
STORE_LOCK_FILENAME ) );
assertThat( e.getMessage(), is( msg ) );
}
}
@Test
public void shouldNotObtainLockWhenStoreAlreadyInUse() throws Exception
{
FileSystemAbstraction fileSystemAbstraction = new CannedFileSystemAbstraction( true, null, null, false, NOTHING );
StoreLocker storeLocker = new StoreLocker( fileSystemAbstraction );
try
{
storeLocker.checkLock( target.cleanDirectory( "unused" ) );
fail();
}
catch ( StoreLockException e )
{
assertThat( e.getMessage(), containsString( "Unable to obtain lock on store lock file" ) );
}
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_StoreLockerTest.java
|
5,696
|
@Deprecated
public class TransactionEventHandlers
implements Lifecycle
{
protected final Collection<TransactionEventHandler> transactionEventHandlers = new CopyOnWriteArraySet<TransactionEventHandler>();
private final TransactionManager txManager;
public TransactionEventHandlers(
TransactionManager txManager
)
{
this.txManager = txManager;
}
@Override
public void init()
throws Throwable
{
}
@Override
public void start()
throws Throwable
{
}
@Override
public void stop()
throws Throwable
{
}
@Override
public void shutdown()
throws Throwable
{
}
public <T> TransactionEventHandler<T> registerTransactionEventHandler(
TransactionEventHandler<T> handler )
{
this.transactionEventHandlers.add( handler );
return handler;
}
public <T> TransactionEventHandler<T> unregisterTransactionEventHandler(
TransactionEventHandler<T> handler )
{
return unregisterHandler( this.transactionEventHandlers, handler );
}
private <T> T unregisterHandler( Collection<?> setOfHandlers, T handler )
{
if ( !setOfHandlers.remove( handler ) )
{
throw new IllegalStateException( handler + " isn't registered" );
}
return handler;
}
public boolean hasHandlers()
{
return !transactionEventHandlers.isEmpty();
}
public void beforeCompletion( TransactionData transactionData,
List<HandlerAndState> states
)
{
for ( TransactionEventHandler<?> handler : this.transactionEventHandlers )
{
try
{
Object state = handler.beforeCommit( transactionData );
states.add( new HandlerAndState( handler, state ) );
}
catch ( Throwable t )
{
// TODO Do something more than calling failure and
// throw exception?
try
{
txManager.setRollbackOnly();
}
catch ( Exception e )
{
// TODO Correct?
e.printStackTrace();
}
// This will cause the transaction to throw a
// TransactionFailureException
throw new RuntimeException( t );
}
}
}
public void afterCompletion( TransactionData transactionData,
int status,
List<HandlerAndState> states
)
{
if ( status == Status.STATUS_COMMITTED )
{
for ( HandlerAndState state : states )
{
state.handler.afterCommit( transactionData, state.state );
}
}
else if ( status == Status.STATUS_ROLLEDBACK )
{
if ( states == null )
{
// This means that the transaction was never successful
return;
}
for ( HandlerAndState state : states )
{
state.handler.afterRollback( transactionData, state.state );
}
}
else
{
throw new RuntimeException( "Unknown status " + status );
}
}
public static class HandlerAndState
{
private final TransactionEventHandler handler;
private final Object state;
public HandlerAndState( TransactionEventHandler<?> handler, Object state )
{
this.handler = handler;
this.state = state;
}
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_TransactionEventHandlers.java
|
5,697
|
public static class DefaultPathDescriptor<T extends Path> implements PathDescriptor<T>
{
@Override
public String nodeRepresentation( Path path, Node node )
{
return "(" + node.getId() + ")";
}
@Override
public String relationshipRepresentation( Path path,
Node from, Relationship relationship )
{
String prefix = "--", suffix = "--";
if ( from.equals( relationship.getEndNode() ) )
{
prefix = "<--";
}
else
{
suffix = "-->";
}
return prefix + "[" + relationship.getType().name() + "," +
relationship.getId() + "]" + suffix;
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_Traversal.java
|
5,698
|
{
@Override
public String nodeRepresentation( Path path, Node node )
{
return "(" + node.getProperty( nodePropertyKey, node.getId() ) + ")";
}
@Override
public String relationshipRepresentation( Path path, Node from,
Relationship relationship )
{
return relationship.getStartNode().equals( from ) ? "-->" : "<--";
}
} );
| false
|
community_kernel_src_main_java_org_neo4j_kernel_Traversal.java
|
5,699
|
{
@Override
public String relationshipRepresentation( Path path, Node from,
Relationship relationship )
{
return relationship.getStartNode().equals( from ) ? "-->" : "<--";
}
} );
| false
|
community_kernel_src_main_java_org_neo4j_kernel_Traversal.java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.