Only have on token implementation

community/kernel/src/main/java/org/neo4j/kernel/NeoStoreDataSource.java

@@ -86,6 +86,7 @@
 import org.neo4j.kernel.impl.locking.StatementLocksFactory;
 import org.neo4j.kernel.impl.logging.LogService;
 import org.neo4j.kernel.impl.newapi.Cursors;
+import org.neo4j.kernel.impl.newapi.KernelToken;
 import org.neo4j.kernel.impl.proc.Procedures;
 import org.neo4j.kernel.impl.storageengine.impl.recordstorage.RecordStorageEngine;
 import org.neo4j.kernel.impl.storageengine.impl.recordstorage.id.IdController;
@@ -668,16 +669,18 @@ private NeoStoreKernelModule buildKernel( LogFiles logFiles, TransactionAppender
                         constraintIndexCreator, databaseSchemaState, explicitIndexStore, cpuClockRef, heapAllocationRef ) );
 
         TransactionHooks hooks = new TransactionHooks();
+        KernelToken token = new KernelToken( storageEngine );
+
         KernelTransactions kernelTransactions = life.add( new KernelTransactions( statementLocksFactory,
                 constraintIndexCreator, statementOperationParts, schemaWriteGuard, transactionHeaderInformationFactory,
                 transactionCommitProcess, indexConfigStore, explicitIndexProviderLookup, hooks, transactionMonitor,
                 availabilityGuard, tracers, storageEngine, procedures, transactionIdStore, clock,
-                cpuClockRef, heapAllocationRef, accessCapability, new Cursors(), autoIndexing, explicitIndexStore ) );
+                cpuClockRef, heapAllocationRef, accessCapability, token, new Cursors(), autoIndexing, explicitIndexStore ) );
 
         buildTransactionMonitor( kernelTransactions, clock, config );
 
         final Kernel kernel = new Kernel( kernelTransactions, hooks, databaseHealth, transactionMonitor, procedures,
-                config, storageEngine );
+                config, storageEngine, token );
 
         kernel.registerTransactionHook( transactionEventHandlers );
         life.add( kernel );

community/kernel/src/main/java/org/neo4j/kernel/impl/api/Kernel.java

@@ -33,6 +33,7 @@
 import org.neo4j.kernel.api.proc.CallableUserAggregationFunction;
 import org.neo4j.kernel.api.proc.CallableUserFunction;
 import org.neo4j.kernel.configuration.Config;
+import org.neo4j.kernel.impl.newapi.KernelToken;
 import org.neo4j.kernel.impl.newapi.NewKernel;
 import org.neo4j.kernel.impl.proc.Procedures;
 import org.neo4j.kernel.impl.transaction.TransactionMonitor;
@@ -78,15 +79,16 @@ public class Kernel extends LifecycleAdapter implements InwardKernel
     private final NewKernel newKernel;
 
     public Kernel( KernelTransactions transactionFactory, TransactionHooks hooks, DatabaseHealth health,
-            TransactionMonitor transactionMonitor, Procedures procedures, Config config, StorageEngine engine )
+            TransactionMonitor transactionMonitor, Procedures procedures, Config config, StorageEngine engine,
+            KernelToken token )
     {
         this.transactions = transactionFactory;
         this.hooks = hooks;
         this.health = health;
         this.transactionMonitor = transactionMonitor;
         this.procedures = procedures;
         this.config = config;
-        this.newKernel = new NewKernel( engine, this );
+        this.newKernel = new NewKernel( engine, token, this );
     }
 
     @Override

community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactionImplementation.java

@@ -76,6 +76,7 @@
 import org.neo4j.kernel.impl.newapi.AllStoreHolder;
 import org.neo4j.kernel.impl.newapi.Cursors;
 import org.neo4j.kernel.impl.newapi.IndexTxStateUpdater;
+import org.neo4j.kernel.impl.newapi.KernelToken;
 import org.neo4j.kernel.impl.newapi.Operations;
 import org.neo4j.kernel.impl.proc.Procedures;
 import org.neo4j.kernel.impl.transaction.TransactionHeaderInformationFactory;
@@ -179,7 +180,7 @@ public KernelTransactionImplementation( StatementOperationParts statementOperati
             TransactionMonitor transactionMonitor, Supplier<ExplicitIndexTransactionState> explicitIndexTxStateSupplier,
             Pool<KernelTransactionImplementation> pool, Clock clock, AtomicReference<CpuClock> cpuClockRef, AtomicReference<HeapAllocation> heapAllocationRef,
             TransactionTracer transactionTracer, LockTracer lockTracer, PageCursorTracerSupplier cursorTracerSupplier,
-            StorageEngine storageEngine, AccessCapability accessCapability, Cursors cursors, AutoIndexing autoIndexing,
+            StorageEngine storageEngine, AccessCapability accessCapability, KernelToken token, Cursors cursors, AutoIndexing autoIndexing,
             ExplicitIndexStore explicitIndexStore )
     {
         this.statementOperations = statementOperations;
@@ -211,7 +212,7 @@ public KernelTransactionImplementation( StatementOperationParts statementOperati
                         allStoreHolder,
                         new IndexTxStateUpdater( storageEngine.storeReadLayer(), allStoreHolder, matcher ),
                         storageStatement,
-                        this, cursors, autoIndexing, matcher );
+                        this, token, cursors, autoIndexing, matcher );
     }
 
     /**

community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactions.java

@@ -46,6 +46,7 @@
 import org.neo4j.kernel.impl.locking.StatementLocks;
 import org.neo4j.kernel.impl.locking.StatementLocksFactory;
 import org.neo4j.kernel.impl.newapi.Cursors;
+import org.neo4j.kernel.impl.newapi.KernelToken;
 import org.neo4j.kernel.impl.proc.Procedures;
 import org.neo4j.kernel.impl.store.TransactionId;
 import org.neo4j.kernel.impl.transaction.TransactionHeaderInformationFactory;
@@ -93,6 +94,7 @@ public class KernelTransactions extends LifecycleAdapter implements Supplier<Ker
     private final ReentrantReadWriteLock newTransactionsLock = new ReentrantReadWriteLock();
     private final MonotonicCounter userTransactionIdCounter = MonotonicCounter.newAtomicMonotonicCounter();
     private final Cursors cursors;
+    private final KernelToken token;
     private final AutoIndexing autoIndexing;
     private final ExplicitIndexStore explicitIndexStore;
 
@@ -132,7 +134,8 @@ public KernelTransactions( StatementLocksFactory statementLocksFactory,
             TransactionMonitor transactionMonitor, AvailabilityGuard availabilityGuard, Tracers tracers,
             StorageEngine storageEngine, Procedures procedures, TransactionIdStore transactionIdStore,
             SystemNanoClock clock,
-            AtomicReference<CpuClock> cpuClockRef, AtomicReference<HeapAllocation> heapAllocationRef, AccessCapability accessCapability, Cursors cursors,
+            AtomicReference<CpuClock> cpuClockRef, AtomicReference<HeapAllocation> heapAllocationRef, AccessCapability accessCapability,
+            KernelToken token, Cursors cursors,
             AutoIndexing autoIndexing,
             ExplicitIndexStore explicitIndexStore )
     {
@@ -160,6 +163,7 @@ public KernelTransactions( StatementLocksFactory statementLocksFactory,
         this.clock = clock;
         blockNewTransactions();
         this.cursors = cursors;
+        this.token = token;
     }
 
     public Supplier<ExplicitIndexTransactionState> explicitIndexTxStateSupplier()
@@ -346,7 +350,8 @@ public KernelTransactionImplementation newInstance()
                             constraintIndexCreator, procedures, transactionHeaderInformationFactory,
                             transactionCommitProcess, transactionMonitor, explicitIndexTxStateSupplier, localTxPool,
                             clock, cpuClockRef, heapAllocationRef, tracers.transactionTracer, tracers.lockTracer,
-                            tracers.pageCursorTracerSupplier, storageEngine, accessCapability, cursors, autoIndexing, explicitIndexStore );
+                            tracers.pageCursorTracerSupplier, storageEngine, accessCapability, token, cursors, autoIndexing,
+                            explicitIndexStore );
             this.transactions.add( tx );
             return tx;
         }

community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/AllStoreHolder.java

@@ -70,7 +70,7 @@
 
 import static java.lang.String.format;
 
-public class AllStoreHolder extends Read implements Token
+public class AllStoreHolder extends Read
 {
     private final StorageStatement.Nodes nodes;
     private final StorageStatement.Groups groups;
@@ -277,78 +277,6 @@ public Iterator<ConstraintDescriptor> constraintsGetAll()
         }, constraints );
     }
 
-    @Override
-    public int labelGetOrCreateForName( String labelName ) throws KernelException
-    {
-        return storeReadLayer.labelGetOrCreateForName( checkValidTokenName( labelName ) );
-    }
-
-    @Override
-    public int propertyKeyGetOrCreateForName( String propertyKeyName ) throws KernelException
-    {
-        return storeReadLayer.propertyKeyGetOrCreateForName( checkValidTokenName( propertyKeyName ) );
-    }
-
-    @Override
-    public int relationshipTypeGetOrCreateForName( String relationshipTypeName ) throws KernelException
-    {
-        throw new UnsupportedOperationException( "not implemented" );
-    }
-
-    @Override
-    public void labelCreateForName( String labelName, int id ) throws KernelException
-    {
-        throw new UnsupportedOperationException( "not implemented" );
-    }
-
-    @Override
-    public String labelGetName( int token ) throws LabelNotFoundKernelException
-    {
-        return storeReadLayer.labelGetName( token );
-    }
-
-    @Override
-    public int labelGetForName( String name )
-    {
-        return storeReadLayer.labelGetForName( name );
-    }
-
-    @Override
-    public void propertyKeyCreateForName( String propertyKeyName, int id ) throws KernelException
-    {
-        throw new UnsupportedOperationException( "not implemented" );
-    }
-
-    @Override
-    public void relationshipTypeCreateForName( String relationshipTypeName, int id ) throws KernelException
-    {
-        throw new UnsupportedOperationException( "not implemented" );
-    }
-
-    @Override
-    public int nodeLabel( String name )
-    {
-        return storeReadLayer.labelGetForName( name );
-    }
-
-    @Override
-    public int relationshipType( String name )
-    {
-        return storeReadLayer.relationshipTypeGetForName( name );
-    }
-
-    @Override
-    public int propertyKey( String name )
-    {
-        return storeReadLayer.propertyKeyGetForName( name );
-    }
-
-    @Override
-    public String propertyKeyGetName( int propertyKeyId ) throws PropertyKeyIdNotFoundKernelException
-    {
-        return storeReadLayer.propertyKeyGetName( propertyKeyId );
-    }
-
     @Override
     PageCursor nodePage( long reference )
     {
@@ -460,15 +388,6 @@ void getOrCreateRelationshipIndexConfig( String indexName, Map<String,String> cu
         explicitIndexStore.getOrCreateRelationshipIndexConfig( indexName, customConfig );
     }
 
-    private String checkValidTokenName( String name ) throws IllegalTokenNameException
-    {
-        if ( name == null || name.isEmpty() )
-        {
-            throw new IllegalTokenNameException( name );
-        }
-        return name;
-    }
-
     String indexGetFailure( IndexDescriptor descriptor ) throws IndexNotFoundKernelException
     {
         return storeReadLayer.indexGetFailure( descriptor.schema() );

community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/KernelSession.java

@@ -25,7 +25,6 @@
 import org.neo4j.internal.kernel.api.security.SecurityContext;
 import org.neo4j.kernel.api.InwardKernel;
 import org.neo4j.kernel.api.KernelTransaction;
-import org.neo4j.storageengine.api.StorageEngine;
 
 /**
  * Implements a Kernel API Session.
@@ -36,11 +35,11 @@ class KernelSession implements Session
     private final SecurityContext securityContext;
     private final KernelToken token;
 
-    KernelSession( StorageEngine engine, InwardKernel kernel, SecurityContext securityContext )
+    KernelSession( KernelToken token, InwardKernel kernel, SecurityContext securityContext )
     {
         this.kernel = kernel;
         this.securityContext = securityContext;
-        this.token = new KernelToken( engine );
+        this.token = token;
     }
 
     @Override

community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/KernelToken.java

@@ -23,6 +23,8 @@
 import org.neo4j.internal.kernel.api.exceptions.KernelException;
 import org.neo4j.internal.kernel.api.exceptions.LabelNotFoundKernelException;
 import org.neo4j.internal.kernel.api.exceptions.PropertyKeyIdNotFoundKernelException;
+import org.neo4j.kernel.api.exceptions.schema.IllegalTokenNameException;
+import org.neo4j.kernel.api.exceptions.schema.TooManyLabelsException;
 import org.neo4j.storageengine.api.StorageEngine;
 import org.neo4j.storageengine.api.StoreReadLayer;
 
@@ -36,15 +38,15 @@ public KernelToken( StorageEngine engine )
     }
 
     @Override
-    public int labelGetOrCreateForName( String labelName ) throws KernelException
+    public int labelGetOrCreateForName( String labelName ) throws IllegalTokenNameException, TooManyLabelsException
     {
-        return store.labelGetOrCreateForName( labelName );
+        return store.labelGetOrCreateForName( checkValidTokenName( labelName ) );
     }
 
     @Override
-    public int propertyKeyGetOrCreateForName( String propertyKeyName ) throws KernelException
+    public int propertyKeyGetOrCreateForName( String propertyKeyName ) throws IllegalTokenNameException
     {
-        return store.propertyKeyGetOrCreateForName( propertyKeyName );
+        return store.propertyKeyGetOrCreateForName( checkValidTokenName( propertyKeyName ) );
     }
 
     @Override
@@ -106,4 +108,13 @@ public String propertyKeyGetName( int propertyKeyId ) throws PropertyKeyIdNotFou
     {
         return store.propertyKeyGetName( propertyKeyId );
     }
+
+    private String checkValidTokenName( String name ) throws IllegalTokenNameException
+    {
+        if ( name == null || name.isEmpty() )
+        {
+            throw new IllegalTokenNameException( name );
+        }
+        return name;
+    }
 }

community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/NewKernel.java

@@ -33,16 +33,18 @@
 public class NewKernel implements Kernel
 {
     private final StorageEngine engine;
+    private final KernelToken token;
     private final InwardKernel kernel;
 
     private StorageStatement statement;
     private Cursors cursors;
 
     private volatile boolean isRunning;
 
-    public NewKernel( StorageEngine engine, InwardKernel kernel )
+    public NewKernel( StorageEngine engine, KernelToken token, InwardKernel kernel )
     {
         this.engine = engine;
+        this.token = token;
         this.kernel = kernel;
         this.isRunning = false;
     }
@@ -58,7 +60,7 @@ public CursorFactory cursors()
     public KernelSession beginSession( SecurityContext securityContext )
     {
         assert isRunning : "kernel is not running, so it is not possible to use it";
-        return new KernelSession( engine, kernel, securityContext );
+        return new KernelSession( token, kernel, securityContext );
     }
 
     public void start()

community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/Operations.java

@@ -77,6 +77,7 @@ public class Operations implements Write, ExplicitIndexWrite
 {
     private final KernelTransactionImplementation ktx;
     private final AllStoreHolder allStoreHolder;
+    private final KernelToken token;
     private final StorageStatement statement;
     private final AutoIndexing autoIndexing;
     private org.neo4j.kernel.impl.newapi.NodeCursor nodeCursor;
@@ -90,8 +91,12 @@ public Operations(
             IndexTxStateUpdater updater,
             StorageStatement statement,
             KernelTransactionImplementation ktx,
-            Cursors cursors, AutoIndexing autoIndexing, NodeSchemaMatcher schemaMatcher )
+            KernelToken token,
+            Cursors cursors,
+            AutoIndexing autoIndexing,
+            NodeSchemaMatcher schemaMatcher )
     {
+        this.token = token;
         this.autoIndexing = autoIndexing;
         this.allStoreHolder = allStoreHolder;
         this.ktx = ktx;
@@ -547,7 +552,7 @@ public void release()
 
     public Token token()
     {
-        return allStoreHolder;
+        return token;
     }
 
     private void acquireExclusiveNodeLock( long node )

community/kernel/src/test/java/org/neo4j/kernel/api/KernelTransactionFactory.java

@@ -40,6 +40,7 @@
 import org.neo4j.kernel.impl.locking.SimpleStatementLocks;
 import org.neo4j.kernel.impl.locking.StatementLocks;
 import org.neo4j.kernel.impl.newapi.Cursors;
+import org.neo4j.kernel.impl.newapi.KernelToken;
 import org.neo4j.kernel.impl.proc.Procedures;
 import org.neo4j.kernel.impl.transaction.TransactionHeaderInformationFactory;
 import org.neo4j.kernel.impl.transaction.TransactionMonitor;
@@ -100,7 +101,7 @@ static Instances kernelTransactionWithInternals( SecurityContext securityContext
                 Clocks.systemClock(), new AtomicReference<>( CpuClock.NOT_AVAILABLE ), new AtomicReference<>( HeapAllocation.NOT_AVAILABLE ), NULL,
                 LockTracer.NONE,
                 PageCursorTracerSupplier.NULL,
-                storageEngine, new CanWrite(), new Cursors(), AutoIndexing.UNSUPPORTED, mock(
+                storageEngine, new CanWrite(), new KernelToken( storageEngine ), new Cursors(), AutoIndexing.UNSUPPORTED, mock(
                 ExplicitIndexStore.class) );
 
         StatementLocks statementLocks = new SimpleStatementLocks( new NoOpClient() );

community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionTerminationTest.java

@@ -44,6 +44,7 @@
 import org.neo4j.kernel.impl.locking.NoOpClient;
 import org.neo4j.kernel.impl.locking.SimpleStatementLocks;
 import org.neo4j.kernel.impl.newapi.Cursors;
+import org.neo4j.kernel.impl.newapi.KernelToken;
 import org.neo4j.kernel.impl.proc.Procedures;
 import org.neo4j.kernel.impl.transaction.TransactionHeaderInformationFactory;
 import org.neo4j.kernel.impl.transaction.TransactionMonitor;
@@ -344,7 +345,7 @@ private static class TestKernelTransaction extends KernelTransactionImplementati
                     new AtomicReference<>( CpuClock.NOT_AVAILABLE ), new AtomicReference<>( HeapAllocation.NOT_AVAILABLE ),
                     TransactionTracer.NULL,
                     LockTracer.NONE, PageCursorTracerSupplier.NULL,
-                    mock( StorageEngine.class, RETURNS_MOCKS ), new CanWrite(), mock( Cursors.class ),
+                    mock( StorageEngine.class, RETURNS_MOCKS ), new CanWrite(), mock( KernelToken.class ), mock( Cursors.class ),
                     AutoIndexing.UNSUPPORTED, mock( ExplicitIndexStore.class ) );
 
             this.monitor = monitor;