Moved code over to enterprise-kernel from enterprise-security

 The moved code was not really security related.

community/kernel/src/main/java/org/neo4j/kernel/builtinprocs/BuiltInProceduresProvider.java

@@ -34,10 +34,16 @@ public BuiltInProceduresProvider()
 
     @Override
     public void registerProcedures( Procedures procedures )
+    {
+        actuallyRegisterProcedures( procedures, BuiltInProcedures.class );
+    }
+
+    // Extracted into a static method this way so it can be re-used from other classes
+    public static void actuallyRegisterProcedures( Procedures procedures, Class<?> proceduresClass )
     {
         try
         {
-            procedures.register( BuiltInProcedures.class );
+            procedures.register( proceduresClass );
         }
         catch ( KernelException e )
         {

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

@@ -95,4 +95,4 @@ public void removingQueryInTheMiddleKeepsOrder()
         // Then
         assertThat( result, equalTo( asList( query1, query2, query4, query5 ) ) );
     }
-}
+}

enterprise/kernel/pom.xml

@@ -158,6 +158,13 @@
       <type>test-jar</type>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.neo4j</groupId>
+      <artifactId>neo4j-common</artifactId>
+      <version>${project.version}</version>
+      <type>test-jar</type>
+      <scope>test</scope>
+    </dependency>
 
     <!-- Test dependencies -->
     <dependency>

enterprise/kernel/src/main/java/org/neo4j/kernel/enterprise/builtinprocs/BuiltInProcedures.java

@@ -0,0 +1,82 @@
+/*
+ * 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 Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.kernel.enterprise.builtinprocs;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.stream.Stream;
+
+import org.neo4j.graphdb.DependencyResolver;
+import org.neo4j.kernel.api.ExecutingQuery;
+import org.neo4j.kernel.api.KernelTransaction;
+import org.neo4j.kernel.api.security.exception.InvalidArgumentsException;
+import org.neo4j.kernel.impl.api.KernelTransactions;
+import org.neo4j.kernel.internal.GraphDatabaseAPI;
+import org.neo4j.procedure.Context;
+import org.neo4j.procedure.Procedure;
+
+import static org.neo4j.procedure.Procedure.Mode.DBMS;
+
+public class BuiltInProcedures
+{
+    @Context
+    public GraphDatabaseAPI graph;
+
+    @Context
+    public KernelTransaction tx;
+
+    @Procedure( name = "dbms.listQueries", mode = DBMS )
+    public Stream<QueryStatusResult> listQueries() throws InvalidArgumentsException, IOException
+    {
+        DependencyResolver resolver = graph.getDependencyResolver();
+        KernelTransactions kernelTransactions = resolver.resolveDependency( KernelTransactions.class );
+        return kernelTransactions.executingQueries().stream().map( this::queryStatusResult );
+    }
+
+    private QueryStatusResult queryStatusResult( ExecutingQuery q )
+    {
+        return new QueryStatusResult(
+                q.queryId(),
+                q.authSubjectName(),
+                q.queryText(),
+                q.queryParameters(),
+                q.startTime()
+        );
+    }
+
+    public static class QueryStatusResult
+    {
+        public final long queryId;
+
+        public final String username;
+        public final String query;
+        public final Map<String,Object> parameters;
+        public final long startTime;
+
+        QueryStatusResult( long queryId, String username, String query, Map<String,Object> parameters, long startTime )
+        {
+            this.queryId = queryId;
+            this.username = username;
+            this.query = query;
+            this.parameters = parameters;
+            this.startTime = startTime;
+        }
+    }
+}

enterprise/kernel/src/test/java/org/neo4j/kernel/enterprise/builtinprocs/BuiltInProceduresIT.java

@@ -0,0 +1,140 @@
+/*
+ * 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 Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.kernel.enterprise.builtinprocs;
+
+import org.hamcrest.Matcher;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import org.neo4j.graphdb.GraphDatabaseService;
+import org.neo4j.graphdb.Result;
+import org.neo4j.test.DoubleLatch;
+import org.neo4j.test.TestEnterpriseGraphDatabaseFactory;
+
+import static org.hamcrest.CoreMatchers.hasItems;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.hasEntry;
+
+public class BuiltInProceduresIT
+{
+    private GraphDatabaseService gds = null;
+
+    @Before
+    public void init()
+    {
+        gds = new TestEnterpriseGraphDatabaseFactory().newImpermanentDatabase();
+    }
+
+    @After
+    public void tearDown()
+    {
+        if ( gds != null )
+        {
+            gds.shutdown();
+        }
+    }
+
+    @Test
+    public void listQueries() throws Throwable
+    {
+        // Given
+        String q1 = "UNWIND [1,2,3] AS x RETURN x";
+        String q2 = "UNWIND [4,5,6] AS x RETURN x";
+        ThreadedTestController controller = new ThreadedTestController( q1, q2 );
+
+        controller.waitForAllThreadsToStart();
+
+        // When
+        String query = "CALL dbms.listQueries()";
+        Result result = gds.execute( query );
+
+        // Then
+        List<Map<String,Object>> actual = result.stream().collect( Collectors.toList() );
+        assertThat( actual, hasItems(
+                hasQuery( q1 ),
+                hasQuery( q2 ),
+                hasQuery( query ) ) );
+
+        controller.waitForThreadsToFinish();
+    }
+
+    private class ThreadedTestController
+    {
+        private final DoubleLatch latch;
+        private final String[] queries;
+        private final ArrayList<Exception> failures = new ArrayList<>();
+
+        ThreadedTestController( String... queries )
+        {
+            this.latch = new DoubleLatch( queries.length + 1, true );
+            this.queries = queries;
+        }
+
+        void waitForAllThreadsToStart()
+        {
+            for ( String query : queries )
+            {
+                Runnable runnable = runQuery( latch, query, failures );
+                new Thread( runnable ).start();
+            }
+        }
+
+        void waitForThreadsToFinish() throws Exception
+        {
+            latch.finishAndWaitForAllToFinish();
+            for ( Exception e : failures )
+            {
+                throw e;
+            }
+        }
+
+        private Runnable runQuery( DoubleLatch latch, String query, ArrayList<Exception> failures )
+        {
+            return () ->
+            {
+                try
+                {
+                    Result result = gds.execute( query );
+                    latch.startAndWaitForAllToStart();
+                    latch.finishAndWaitForAllToFinish();
+                    result.close();
+
+                }
+                catch ( Exception e )
+                {
+                    failures.add( e );
+                }
+            };
+        }
+    }
+
+    @SuppressWarnings( "unchecked" )
+    private Matcher<Map<String,Object>> hasQuery( String query )
+    {
+        return (Matcher<Map<String,Object>>) (Matcher) hasEntry( equalTo( "query" ), equalTo( query ) );
+    }
+}

enterprise/kernel/src/test/java/org/neo4j/kernel/enterprise/builtinprocs/BuiltInProceduresProvider.java

@@ -0,0 +1,41 @@
+/*
+ * 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 Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.kernel.enterprise.builtinprocs;
+
+import org.neo4j.helpers.Service;
+import org.neo4j.kernel.impl.factory.ProceduresProvider;
+import org.neo4j.kernel.impl.proc.Procedures;
+
+import static org.neo4j.kernel.builtinprocs.BuiltInProceduresProvider.actuallyRegisterProcedures;
+
+@Service.Implementation( ProceduresProvider.class )
+public class BuiltInProceduresProvider extends Service implements ProceduresProvider
+{
+    public BuiltInProceduresProvider()
+    {
+        super( "built-in-enterprise-procedures-provider" );
+    }
+
+    @Override
+    public void registerProcedures( Procedures procedures )
+    {
+        actuallyRegisterProcedures( procedures, BuiltInProcedures.class );
+    }
+}

enterprise/security/src/main/java/org/neo4j/server/security/enterprise/auth/AuthProcedures.java

@@ -262,40 +262,6 @@ public Stream<TransactionResult> listTransactions()
                 );
     }
 
-    @Procedure( name = "dbms.listQueries", mode = DBMS )
-    public Stream<QueryStatusResult> listQueries()
-            throws InvalidArgumentsException, IOException
-    {
-        try ( Statement statement = tx.acquireStatement() )
-        {
-            // Expected to always succeed
-            ExecutingQuery ownQuery = statement.metaOperations().executingQueries().findFirst().get();
-            DependencyResolver resolver = graph.getDependencyResolver();
-            KernelTransactions kernelTransactions = resolver.resolveDependency( KernelTransactions.class );
-            Set<ExecutingQuery> executingQueries = kernelTransactions.executingQueries();
-            executingQueries.removeIf( isEqual( ownQuery ) );
-            return executingQueries.stream().map( this::queryStatusResult );
-        }
-    }
-
-    private QueryStatusResult queryStatusResult( ExecutingQuery q )
-    {
-        return new QueryStatusResult(
-            q.queryId(),
-            q.authSubjectName(),
-            q.queryText(),
-            q.queryParameters(),
-            q.startTime()
-        );
-    }
-
-    @Procedure( name = "dbms.listQueriesForUser", mode = DBMS )
-    public Stream<QueryStatusResult> listQueriesForUser( @Name( "username") String username )
-            throws InvalidArgumentsException, IOException
-    {
-        throw new NotImplementedException();
-    }
-
     @Procedure( name = "dbms.security.terminateTransactionsForUser", mode = DBMS )
     public Stream<TransactionTerminationResult> terminateTransactionsForUser( @Name( "username" ) String username )
             throws InvalidArgumentsException, IOException