diff --git a/community/cypher/cypher-compiler-3.0/src/main/scala/org/neo4j/cypher/internal/compiler/v3_0/spi/DelegatingQueryContext.scala b/community/cypher/cypher-compiler-3.0/src/main/scala/org/neo4j/cypher/internal/compiler/v3_0/spi/DelegatingQueryContext.scala index 851ea095a9af..ee0fb20072d0 100644 --- a/community/cypher/cypher-compiler-3.0/src/main/scala/org/neo4j/cypher/internal/compiler/v3_0/spi/DelegatingQueryContext.scala +++ b/community/cypher/cypher-compiler-3.0/src/main/scala/org/neo4j/cypher/internal/compiler/v3_0/spi/DelegatingQueryContext.scala @@ -230,8 +230,12 @@ class DelegatingQueryTransactionalContext(val inner: QueryTransactionalContext) override type ReadOps = inner.ReadOps + override type DbmsOps = inner.DbmsOps + override def readOperations: ReadOps = inner.readOperations + override def dbmsOperations: DbmsOps = inner.dbmsOperations + override def commitAndRestartTx() { inner.commitAndRestartTx() } override def isTopLevelTx: Boolean = inner.isTopLevelTx diff --git a/community/cypher/cypher-compiler-3.0/src/main/scala/org/neo4j/cypher/internal/compiler/v3_0/spi/QueryContext.scala b/community/cypher/cypher-compiler-3.0/src/main/scala/org/neo4j/cypher/internal/compiler/v3_0/spi/QueryContext.scala index 3e213687a2c5..99b00c3288ac 100644 --- a/community/cypher/cypher-compiler-3.0/src/main/scala/org/neo4j/cypher/internal/compiler/v3_0/spi/QueryContext.scala +++ b/community/cypher/cypher-compiler-3.0/src/main/scala/org/neo4j/cypher/internal/compiler/v3_0/spi/QueryContext.scala @@ -196,9 +196,12 @@ trait Operations[T <: PropertyContainer] { trait QueryTransactionalContext { type ReadOps + type DbmsOps def readOperations: ReadOps + def dbmsOperations: DbmsOps + def isTopLevelTx: Boolean def close(success: Boolean) diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/ExecutionEngine.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/ExecutionEngine.scala index 632fd853850d..271ee3929ee3 100644 --- a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/ExecutionEngine.scala +++ b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/ExecutionEngine.scala @@ -138,7 +138,7 @@ class ExecutionEngine(val queryService: GraphDatabaseQueryService, logProvider: val tc = externalTransactionalContext.provideContext() // Temporarily change access mode during query planning - val revertable = tc.restrict(AccessMode.Static.READ) + val revertable = tc.restrictCurrentTransaction(AccessMode.Static.READ) val ((plan: ExecutionPlan, extractedParameters), touched) = try { // fetch plan cache diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/TransactionalContextWrapper.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/TransactionalContextWrapper.scala index 1ed9a3d49cef..ae12e74795e3 100644 --- a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/TransactionalContextWrapper.scala +++ b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/TransactionalContextWrapper.scala @@ -25,13 +25,15 @@ import org.neo4j.kernel.GraphDatabaseQueryService import org.neo4j.kernel.api.KernelTransaction.Revertable import org.neo4j.kernel.api.security.AccessMode import org.neo4j.kernel.api.txstate.TxStateHolder -import org.neo4j.kernel.api.{ReadOperations, Statement} +import org.neo4j.kernel.api.{DbmsOperations, ReadOperations, Statement} import org.neo4j.kernel.impl.query.TransactionalContext case class TransactionalContextWrapper(tc: TransactionalContext) extends QueryTransactionalContext { override type ReadOps = ReadOperations + override type DbmsOps = DbmsOperations + def provideContext(): TransactionalContextWrapper = TransactionalContextWrapper(tc.provideContext()) def isOpen: Boolean = tc.isOpen @@ -49,11 +51,15 @@ case class TransactionalContextWrapper(tc: TransactionalContext) extends QueryTr override def readOperations: ReadOperations = tc.readOperations() + override def dbmsOperations: DbmsOperations = tc.dbmsOperations() + override def commitAndRestartTx() { tc.commitAndRestartTx() } override def isTopLevelTx: Boolean = tc.isTopLevelTx override def close(success: Boolean) { tc.close(success) } - def restrict(accessMode: AccessMode): Revertable = tc.restrict(accessMode) + def restrictCurrentTransaction(accessMode: AccessMode): Revertable = tc.restrictCurrentTransaction(accessMode) + + def accessMode: AccessMode = tc.accessMode } diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_0/TransactionBoundQueryContext.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_0/TransactionBoundQueryContext.scala index e832d7fdfe42..3743eab21ebb 100644 --- a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_0/TransactionBoundQueryContext.scala +++ b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_0/TransactionBoundQueryContext.scala @@ -554,7 +554,9 @@ final class TransactionBoundQueryContext(val transactionalContext: Transactional callProcedure(name, args, transactionalContext.statement.dataWriteOperations().procedureCallWrite ) override def callDbmsProcedure(name: ProcedureName, args: Seq[Any]) = - callProcedure(name, args, transactionalContext.statement.dbmsOperations().procedureCallDbms ) + callProcedure(name, args, + (kn: proc.ProcedureSignature.ProcedureName, input: Array[AnyRef]) => + transactionalContext.dbmsOperations.procedureCallDbms(kn, input, transactionalContext.accessMode)) private def callProcedure(name: ProcedureName, args: Seq[Any], call: (proc.ProcedureSignature.ProcedureName, Array[AnyRef]) => RawIterator[Array[AnyRef], ProcedureException]) = { diff --git a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/LazyTest.scala b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/LazyTest.scala index 3ee43ffce6b4..6c11c8c346b6 100644 --- a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/LazyTest.scala +++ b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_0/LazyTest.scala @@ -245,8 +245,8 @@ class LazyTest extends ExecutionEngineFunSuite { val tx = fakeGraph.beginTransaction(KernelTransaction.Type.`implicit`, AccessMode.Static.FULL) val context = new Neo4jTransactionalContext(service, tx, fakeStatement, new PropertyContainerLocker) - val revertableRestrict = mock[Revertable] - when(context.restrict(anyObject())).thenReturn(revertableRestrict) + val revertable = mock[Revertable] + when(context.restrictCurrentTransaction(anyObject())).thenReturn(revertable) val session = QueryEngineProvider.embeddedSession(context) //When: diff --git a/community/kernel/src/main/java/org/neo4j/kernel/api/DbmsOperations.java b/community/kernel/src/main/java/org/neo4j/kernel/api/DbmsOperations.java index 97dcc6902f80..140fa19fb4ef 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/api/DbmsOperations.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/api/DbmsOperations.java @@ -19,41 +19,10 @@ */ package org.neo4j.kernel.api; -import java.util.Iterator; -import java.util.Map; -import java.util.Set; -import java.util.function.Function; - import org.neo4j.collection.RawIterator; -import org.neo4j.collection.primitive.PrimitiveIntIterator; -import org.neo4j.collection.primitive.PrimitiveLongIterator; -import org.neo4j.cursor.Cursor; -import org.neo4j.graphdb.Direction; -import org.neo4j.kernel.api.constraints.NodePropertyConstraint; -import org.neo4j.kernel.api.constraints.PropertyConstraint; -import org.neo4j.kernel.api.constraints.RelationshipPropertyConstraint; -import org.neo4j.kernel.api.exceptions.EntityNotFoundException; -import org.neo4j.kernel.api.exceptions.LabelNotFoundKernelException; import org.neo4j.kernel.api.exceptions.ProcedureException; -import org.neo4j.kernel.api.exceptions.PropertyKeyIdNotFoundKernelException; -import org.neo4j.kernel.api.exceptions.RelationshipTypeIdNotFoundKernelException; -import org.neo4j.kernel.api.exceptions.index.IndexNotFoundKernelException; -import org.neo4j.kernel.api.exceptions.legacyindex.LegacyIndexNotFoundKernelException; -import org.neo4j.kernel.api.exceptions.schema.DuplicateIndexSchemaRuleException; -import org.neo4j.kernel.api.exceptions.schema.IndexBrokenKernelException; -import org.neo4j.kernel.api.exceptions.schema.SchemaRuleNotFoundException; -import org.neo4j.kernel.api.index.IndexDescriptor; -import org.neo4j.kernel.api.index.InternalIndexState; -import org.neo4j.kernel.api.proc.CallableProcedure; import org.neo4j.kernel.api.proc.ProcedureSignature; -import org.neo4j.kernel.impl.api.RelationshipVisitor; -import org.neo4j.kernel.impl.api.store.RelationshipIterator; -import org.neo4j.register.Register.DoubleLongRegister; -import org.neo4j.storageengine.api.NodeItem; -import org.neo4j.storageengine.api.RelationshipItem; -import org.neo4j.storageengine.api.Token; -import org.neo4j.storageengine.api.lock.ResourceType; -import org.neo4j.storageengine.api.schema.PopulationProgress; +import org.neo4j.kernel.api.security.AccessMode; /** * Defines all types of system-oriented operations - i.e. those which do not read from or write to the graph - that can be done from the {@link KernelAPI}. @@ -66,9 +35,6 @@ public interface DbmsOperations //================================================= /** Invoke a DBMS procedure by name */ - RawIterator procedureCallDbms( ProcedureSignature.ProcedureName name, Object[] input ) throws ProcedureException; - - //================================================= - //== AUTH OPERATIONS == - //================================================= + RawIterator procedureCallDbms( ProcedureSignature.ProcedureName name, Object[] input, + AccessMode accessMode ) throws ProcedureException; } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/api/Statement.java b/community/kernel/src/main/java/org/neo4j/kernel/api/Statement.java index cc46f790fd6f..24f723e19680 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/api/Statement.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/api/Statement.java @@ -58,9 +58,4 @@ public interface Statement extends Resource * and it's of a different type, e.g {@link #dataWriteOperations()}. */ SchemaWriteOperations schemaWriteOperations() throws InvalidTransactionTypeKernelException; - - /** - * @return interface exposing all DBMS operations. - */ - DbmsOperations dbmsOperations(); } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/api/proc/CallableProcedure.java b/community/kernel/src/main/java/org/neo4j/kernel/api/proc/CallableProcedure.java index a641ec401672..5f3b9e19307c 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/api/proc/CallableProcedure.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/api/proc/CallableProcedure.java @@ -26,6 +26,7 @@ import org.neo4j.kernel.api.KernelTransaction; import org.neo4j.kernel.api.exceptions.ProcedureException; import org.neo4j.kernel.api.exceptions.Status; +import org.neo4j.kernel.api.security.AccessMode; public interface CallableProcedure { @@ -41,6 +42,7 @@ public interface CallableProcedure interface Context { Key KERNEL_TRANSACTION = Key.key( "KernelTransaction", KernelTransaction.class ); + Key ACCESS_MODE = Key.key( "AccessMode", AccessMode.class ); T get( Key key ) throws ProcedureException; } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/builtinprocs/AlterUserPasswordProcedure.java b/community/kernel/src/main/java/org/neo4j/kernel/builtinprocs/AlterUserPasswordProcedure.java index 8d5d7a879ebb..af6c03f4ac3b 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/builtinprocs/AlterUserPasswordProcedure.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/builtinprocs/AlterUserPasswordProcedure.java @@ -54,7 +54,7 @@ public AlterUserPasswordProcedure( ProcedureName name ) @Override public RawIterator apply( Context ctx, Object[] input ) throws ProcedureException { - AccessMode accessMode = ctx.get( Context.KERNEL_TRANSACTION ).mode(); + AccessMode accessMode = ctx.get( Context.ACCESS_MODE ); if ( !(accessMode instanceof AuthSubject) ) { throw new AuthorizationViolationException( "Invalid attempt to change the password" ); @@ -69,7 +69,7 @@ public RawIterator apply( Context ctx, Object[] inp catch ( IOException e ) { throw new ProcedureException( Status.Security.Forbidden, e, - "The password was not able to be changed for the provided username"); + "Failed to change the password for the provided username" ); } } } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelStatement.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelStatement.java index 26fb84a4d54f..a5e157924111 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelStatement.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelStatement.java @@ -22,7 +22,6 @@ import org.neo4j.graphdb.NotInTransactionException; import org.neo4j.graphdb.TransactionTerminatedException; import org.neo4j.graphdb.security.AuthorizationViolationException; -import org.neo4j.kernel.api.DbmsOperations; import org.neo4j.kernel.api.DataWriteOperations; import org.neo4j.kernel.api.ReadOperations; import org.neo4j.kernel.api.SchemaWriteOperations; @@ -117,12 +116,6 @@ public SchemaWriteOperations schemaWriteOperations() return facade; } - @Override - public DbmsOperations dbmsOperations() - { - return facade; - } - @Override public TransactionState txState() { diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/NonTransactionalDbmsOperations.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/NonTransactionalDbmsOperations.java new file mode 100644 index 000000000000..182b1aedd4c5 --- /dev/null +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/NonTransactionalDbmsOperations.java @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2002-2016 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * This file is part of Neo4j. + * + * Neo4j is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package org.neo4j.kernel.impl.api; + +import org.neo4j.collection.RawIterator; +import org.neo4j.kernel.api.DbmsOperations; +import org.neo4j.kernel.api.exceptions.ProcedureException; +import org.neo4j.kernel.api.proc.CallableProcedure; +import org.neo4j.kernel.api.proc.ProcedureSignature; +import org.neo4j.kernel.api.security.AccessMode; +import org.neo4j.kernel.impl.proc.Procedures; + +public class NonTransactionalDbmsOperations implements DbmsOperations +{ + + private final Procedures procedures; + + public NonTransactionalDbmsOperations( Procedures procedures ) + { + this.procedures = procedures; + } + + @Override + public RawIterator procedureCallDbms( ProcedureSignature.ProcedureName name, + Object[] input, AccessMode accessMode ) throws ProcedureException + { + CallableProcedure.BasicContext ctx = new CallableProcedure.BasicContext(); + ctx.put( CallableProcedure.Context.ACCESS_MODE, accessMode ); + return procedures.call( ctx, name, input ); + } + +} diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/OperationsFacade.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/OperationsFacade.java index 47e2c160954f..858d1f017ca4 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/OperationsFacade.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/OperationsFacade.java @@ -31,7 +31,6 @@ import org.neo4j.cursor.Cursor; import org.neo4j.graphdb.Direction; import org.neo4j.kernel.api.security.AccessMode; -import org.neo4j.kernel.api.DbmsOperations; import org.neo4j.kernel.api.DataWriteOperations; import org.neo4j.kernel.api.KernelTransaction; import org.neo4j.kernel.api.LegacyIndexHits; @@ -91,7 +90,7 @@ import org.neo4j.storageengine.api.lock.ResourceType; import org.neo4j.storageengine.api.schema.PopulationProgress; -public class OperationsFacade implements ReadOperations, DataWriteOperations, SchemaWriteOperations, DbmsOperations +public class OperationsFacade implements ReadOperations, DataWriteOperations, SchemaWriteOperations { private final KernelTransaction tx; private final KernelStatement statement; @@ -1099,21 +1098,6 @@ public void uniqueIndexDrop( IndexDescriptor descriptor ) throws DropIndexFailur // - // - - @Override - public RawIterator procedureCallDbms( ProcedureName name, - Object[] input ) throws ProcedureException - { - statement.assertOpen(); - - CallableProcedure.BasicContext ctx = new CallableProcedure.BasicContext(); - ctx.put( CallableProcedure.Context.KERNEL_TRANSACTION, tx ); - return procedures.call( ctx, name, input ); - } - - // - // @Override public void acquireExclusive( ResourceType type, long id ) diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/factory/DataSourceModule.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/factory/DataSourceModule.java index c62f5ac05a8b..5ea3b3a563f7 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/factory/DataSourceModule.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/factory/DataSourceModule.java @@ -36,6 +36,7 @@ import org.neo4j.kernel.AvailabilityGuard; import org.neo4j.kernel.DatabaseAvailability; import org.neo4j.kernel.NeoStoreDataSource; +import org.neo4j.kernel.api.DbmsOperations; import org.neo4j.kernel.api.KernelAPI; import org.neo4j.kernel.api.KernelTransaction; import org.neo4j.kernel.api.Statement; @@ -43,6 +44,7 @@ import org.neo4j.kernel.builtinprocs.BuiltInProcedures; import org.neo4j.kernel.configuration.Config; import org.neo4j.kernel.guard.Guard; +import org.neo4j.kernel.impl.api.NonTransactionalDbmsOperations; import org.neo4j.kernel.impl.api.NonTransactionalTokenNameLookup; import org.neo4j.kernel.impl.api.SchemaWriteGuard; import org.neo4j.kernel.impl.api.index.IndexingService; @@ -165,6 +167,9 @@ public DataSourceModule( final GraphDatabaseFacadeFactory.Dependencies dependenc this.queryExecutor = queryExecutor::get; Procedures procedures = setupProcedures( platformModule, editionModule.coreAPIAvailabilityGuard ); + DbmsOperations dbmsOperations = new NonTransactionalDbmsOperations( procedures ); + deps.satisfyDependency( dbmsOperations ); + NonTransactionalTokenNameLookup tokenNameLookup = new NonTransactionalTokenNameLookup( editionModule.labelTokenHolder, editionModule.relationshipTypeTokenHolder, diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/query/Neo4jTransactionalContext.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/query/Neo4jTransactionalContext.java index ba7ceb81bead..52e628dd233f 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/query/Neo4jTransactionalContext.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/query/Neo4jTransactionalContext.java @@ -22,6 +22,7 @@ import org.neo4j.graphdb.Lock; import org.neo4j.graphdb.PropertyContainer; import org.neo4j.kernel.GraphDatabaseQueryService; +import org.neo4j.kernel.api.DbmsOperations; import org.neo4j.kernel.api.KernelTransaction; import org.neo4j.kernel.api.ReadOperations; import org.neo4j.kernel.api.Statement; @@ -38,6 +39,7 @@ public class Neo4jTransactionalContext implements TransactionalContext private final ThreadToStatementContextBridge txBridge; private final KernelTransaction.Type transactionType; private final AccessMode mode; + private final DbmsOperations dbmsOperations; private InternalTransaction transaction; private Statement statement; @@ -55,6 +57,7 @@ public Neo4jTransactionalContext( GraphDatabaseQueryService graph, InternalTrans this.statement = initialStatement; this.locker = locker; this.txBridge = graph.getDependencyResolver().resolveDependency( ThreadToStatementContextBridge.class ); + this.dbmsOperations = graph.getDependencyResolver().resolveDependency( DbmsOperations.class ); } @Override @@ -63,6 +66,12 @@ public ReadOperations readOperations() return statement.readOperations(); } + @Override + public DbmsOperations dbmsOperations() + { + return dbmsOperations; + } + @Override public boolean isTopLevelTx() { @@ -163,8 +172,14 @@ public Lock acquireWriteLock( PropertyContainer p ) } @Override - public KernelTransaction.Revertable restrict( AccessMode accessMode ) + public KernelTransaction.Revertable restrictCurrentTransaction( AccessMode accessMode ) { return transaction.restrict( accessMode ); } + + @Override + public AccessMode accessMode() + { + return mode; + } } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/query/TransactionalContext.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/query/TransactionalContext.java index ae09824252af..0ebef242f087 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/query/TransactionalContext.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/query/TransactionalContext.java @@ -22,6 +22,7 @@ import org.neo4j.graphdb.Lock; import org.neo4j.graphdb.PropertyContainer; import org.neo4j.kernel.GraphDatabaseQueryService; +import org.neo4j.kernel.api.DbmsOperations; import org.neo4j.kernel.api.KernelTransaction; import org.neo4j.kernel.api.ReadOperations; import org.neo4j.kernel.api.Statement; @@ -32,6 +33,8 @@ public interface TransactionalContext { ReadOperations readOperations(); + DbmsOperations dbmsOperations(); + boolean isTopLevelTx(); void close( boolean success ); @@ -55,5 +58,7 @@ public interface TransactionalContext QuerySession.MetadataKey metadataKey = new QuerySession.MetadataKey<>( TransactionalContext.class, "transaction context" ); - KernelTransaction.Revertable restrict( AccessMode accessMode ); + AccessMode accessMode(); + + KernelTransaction.Revertable restrictCurrentTransaction( AccessMode accessMode ); } diff --git a/community/kernel/src/test/java/org/neo4j/kernel/builtinprocs/BuiltInProceduresTest.java b/community/kernel/src/test/java/org/neo4j/kernel/builtinprocs/BuiltInProceduresTest.java index 30a2d7329497..6c726dd46728 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/builtinprocs/BuiltInProceduresTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/builtinprocs/BuiltInProceduresTest.java @@ -232,7 +232,6 @@ public void setup() throws Exception when(tx.acquireStatement()).thenReturn( statement ); when(statement.readOperations()).thenReturn( read ); - when(statement.dbmsOperations()).thenReturn( dbms ); when(read.propertyKeyGetAllTokens()).thenAnswer( asTokens(propKeys) ); when(read.labelsGetAllTokens()).thenAnswer( asTokens(labels) ); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/integrationtest/BuiltinProceduresIT.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/integrationtest/BuiltinProceduresIT.java index 11aa9186f5c6..62085895f52d 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/integrationtest/BuiltinProceduresIT.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/integrationtest/BuiltinProceduresIT.java @@ -27,14 +27,8 @@ import org.neo4j.graphdb.security.AuthorizationViolationException; import org.neo4j.kernel.api.DataWriteOperations; import org.neo4j.kernel.api.exceptions.ProcedureException; +import org.neo4j.kernel.api.security.AccessMode; import org.neo4j.server.security.auth.AuthSubject; -import org.neo4j.server.security.auth.AuthenticationResult; -import org.neo4j.server.security.auth.AuthenticationStrategy; -import org.neo4j.server.security.auth.BasicAuthManager; -import org.neo4j.server.security.auth.BasicAuthSubject; -import org.neo4j.server.security.auth.FileUserRepository; -import org.neo4j.server.security.auth.User; -import org.neo4j.server.security.auth.UserRepository; import static junit.framework.TestCase.fail; import static org.hamcrest.MatcherAssert.assertThat; @@ -43,7 +37,7 @@ import static org.hamcrest.Matchers.emptyIterable; import static org.hamcrest.core.IsEqual.equalTo; import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.when; +import static org.mockito.Mockito.verify; import static org.neo4j.helpers.collection.Iterators.asList; import static org.neo4j.kernel.api.proc.ProcedureSignature.procedureName; @@ -75,13 +69,14 @@ public void failWhenCallingListAllLabelsInDbmsMode() throws Throwable try { // When - RawIterator stream = dbmsOperationsInNewTransaction().procedureCallDbms( procedureName( "db", "labels" ), new Object[0] ); + RawIterator stream = dbmsOperations().procedureCallDbms( procedureName( "db", "labels" ), new Object[0], + AccessMode.Static.NONE ); fail( "Should have failed." ); } catch (Exception e) { // Then - assertThat( e.getClass(), equalTo( AuthorizationViolationException.class ) ); + assertThat( e.getClass(), equalTo( ProcedureException.class ) ); } } @@ -106,13 +101,13 @@ public void failWhenCallingListPropertyKeysInDbmsMode() throws Throwable try { // When - RawIterator stream = dbmsOperationsInNewTransaction().procedureCallDbms( procedureName( "db", "propertyKeys" ), new Object[0] ); + RawIterator stream = dbmsOperations().procedureCallDbms( procedureName( "db", "propertyKeys" ), new Object[0], AccessMode.Static.NONE ); fail( "Should have failed." ); } catch (Exception e) { // Then - assertThat( e.getClass(), equalTo( AuthorizationViolationException.class ) ); + assertThat( e.getClass(), equalTo( ProcedureException.class ) ); } } @@ -138,13 +133,13 @@ public void failWhenCallingListRelationshipTypesInDbmsMode() throws Throwable try { // When - RawIterator stream = dbmsOperationsInNewTransaction().procedureCallDbms( procedureName( "db", "relationshipTypes" ), new Object[0] ); + RawIterator stream = dbmsOperations().procedureCallDbms( procedureName( "db", "relationshipTypes" ), new Object[0], AccessMode.Static.NONE ); fail( "Should have failed." ); } catch (Exception e) { // Then - assertThat( e.getClass(), equalTo( AuthorizationViolationException.class ) ); + assertThat( e.getClass(), equalTo( ProcedureException.class ) ); } } @@ -175,14 +170,15 @@ public void failWhenCallingListProceduresInDbmsMode() throws Throwable { // When RawIterator stream = - dbmsOperationsInNewTransaction() - .procedureCallDbms( procedureName( "sys", "procedures" ), new Object[0] ); + dbmsOperations() + .procedureCallDbms( procedureName( "sys", "procedures" ), new Object[0], + AccessMode.Static.NONE ); assertThat( "This should never get here", 1 == 2 ); } catch (Exception e) { // Then - assertThat( e.getClass(), equalTo( AuthorizationViolationException.class ) ); + assertThat( e.getClass(), equalTo( ProcedureException.class ) ); } } @@ -192,19 +188,14 @@ public void callChangePasswordWithAccessModeInDbmsMode() throws Throwable // Given Object[] inputArray = new Object[1]; inputArray[0] = "newPassword"; - - UserRepository userRepository = mock( FileUserRepository.class ); - BasicAuthManager authManager = new BasicAuthManager( userRepository, mock( AuthenticationStrategy.class ) ); - when( userRepository.isValidName( "neo4j" ) ).thenReturn( true ); - User user = authManager.newUser( "neo4j", "neo4j", true ); - when( userRepository.findByName( "neo4j" ) ).thenReturn( user ); - AuthSubject authSubject = new BasicAuthSubject( authManager, user, AuthenticationResult.PASSWORD_CHANGE_REQUIRED ); + AuthSubject authSubject = mock( AuthSubject.class ); // When - RawIterator < Object[],ProcedureException> stream = dbmsOperationsWithAuthSubjectInNewTransaction( authSubject ) - .procedureCallDbms( procedureName( "sys", "changePassword" ), inputArray ); + RawIterator < Object[],ProcedureException> stream = dbmsOperations() + .procedureCallDbms( procedureName( "sys", "changePassword" ), inputArray, authSubject ); // Then + verify( authSubject ).setPassword( (String) inputArray[0] ); assertThat( asList( stream ), emptyIterable() ); } @@ -218,8 +209,9 @@ public void shouldFailWhenChangePasswordWithStaticAccessModeInDbmsMode() throws inputArray[0] = "newPassword"; // When - RawIterator stream = dbmsOperationsInNewTransaction() - .procedureCallDbms( procedureName( "sys", "changePassword" ), inputArray ); + RawIterator stream = dbmsOperations() + .procedureCallDbms( procedureName( "sys", "changePassword" ), inputArray, + AccessMode.Static.NONE ); fail( "Should have failed." ); } catch ( Exception e ) diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/integrationtest/KernelIntegrationTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/integrationtest/KernelIntegrationTest.java index fb698858ea0d..b36b2e0e5818 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/integrationtest/KernelIntegrationTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/integrationtest/KernelIntegrationTest.java @@ -52,6 +52,7 @@ public abstract class KernelIntegrationTest private KernelTransaction transaction; private Statement statement; private EphemeralFileSystemAbstraction fs; + private DbmsOperations dbmsOperations; protected TokenWriteOperations tokenWriteOperationsInNewTransaction() throws KernelException { @@ -81,18 +82,9 @@ protected ReadOperations readOperationsInNewTransaction() throws TransactionFail return statement.readOperations(); } - protected DbmsOperations dbmsOperationsInNewTransaction() throws TransactionFailureException + protected DbmsOperations dbmsOperations() { - transaction = kernel.newTransaction( KernelTransaction.Type.implicit, AccessMode.Static.NONE ); - statement = transaction.acquireStatement(); - return statement.dbmsOperations(); - } - - protected DbmsOperations dbmsOperationsWithAuthSubjectInNewTransaction(AccessMode accessMode) throws TransactionFailureException - { - transaction = kernel.newTransaction( KernelTransaction.Type.implicit, accessMode ); - statement = transaction.acquireStatement(); - return statement.dbmsOperations(); + return dbmsOperations; } protected void commit() throws TransactionFailureException @@ -145,6 +137,7 @@ protected void startDb() kernel = db.getDependencyResolver().resolveDependency( KernelAPI.class ); indexingService = db.getDependencyResolver().resolveDependency( IndexingService.class ); statementContextSupplier = db.getDependencyResolver().resolveDependency( ThreadToStatementContextBridge.class ); + dbmsOperations = db.getDependencyResolver().resolveDependency( DbmsOperations.class ); } protected GraphDatabaseService createGraphDatabase( EphemeralFileSystemAbstraction fs )