Extract inner classes out of the JobScheduler interface, and into top…

…-level.

community/common/src/main/java/org/neo4j/scheduler/CancelListener.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2002-2018 "Neo4j,"
+ * Neo4j Sweden AB [http://neo4j.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 <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.scheduler;
+
+/**
+ * Gets notified about calls to {@link JobHandle#cancel(boolean)}.
+ */
+public interface CancelListener
+{
+    /**
+     * Notification that {@link JobHandle#cancel(boolean)} was called.
+     *
+     * @param mayInterruptIfRunning argument from {@link JobHandle#cancel(boolean)} call.
+     */
+    void cancelled( boolean mayInterruptIfRunning );
+}

community/common/src/main/java/org/neo4j/scheduler/Group.java

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2002-2018 "Neo4j,"
+ * Neo4j Sweden AB [http://neo4j.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 <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.scheduler;
+
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Represents a common group of jobs, defining how they should be scheduled.
+ */
+public final class Group
+{
+    private final AtomicInteger threadCounter = new AtomicInteger();
+    private final String name;
+
+    Group( String name )
+    {
+        Objects.requireNonNull( name, "Group name cannot be null." );
+        this.name = name;
+    }
+
+    public String name()
+    {
+        return name;
+    }
+
+    /**
+     * Name a new thread. This method may or may not be used, it is up to the scheduling strategy to decide
+     * to honor this.
+     */
+    public String threadName()
+    {
+        return "neo4j." + name() + "-" + threadCounter.incrementAndGet();
+    }
+
+    @Override
+    public boolean equals( Object o )
+    {
+        if ( this == o )
+        {
+            return true;
+        }
+        if ( o == null || getClass() != o.getClass() )
+        {
+            return false;
+        }
+
+        Group group = (Group) o;
+
+        return name.equals( group.name );
+    }
+
+    @Override
+    public int hashCode()
+    {
+        return name.hashCode();
+    }
+}

community/common/src/main/java/org/neo4j/scheduler/JobHandle.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2002-2018 "Neo4j,"
+ * Neo4j Sweden AB [http://neo4j.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 <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.scheduler;
+
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+
+public interface JobHandle
+{
+    void cancel( boolean mayInterruptIfRunning );
+
+    void waitTermination() throws InterruptedException, ExecutionException, CancellationException;
+
+    default void registerCancelListener( CancelListener listener )
+    {
+        throw new UnsupportedOperationException( "Unsupported in this implementation" );
+    }
+}

community/common/src/main/java/org/neo4j/scheduler/JobScheduler.java

@@ -19,15 +19,11 @@
  */
 package org.neo4j.scheduler;
 
-import java.util.Objects;
-import java.util.concurrent.CancellationException;
-import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.ForkJoinPool;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
 
 import org.neo4j.kernel.lifecycle.Lifecycle;
 
@@ -37,58 +33,6 @@
  */
 public interface JobScheduler extends Lifecycle
 {
-    /**
-     * Represents a common group of jobs, defining how they should be scheduled.
-     */
-    final class Group
-    {
-        private final AtomicInteger threadCounter = new AtomicInteger();
-        private final String name;
-
-        private Group( String name )
-        {
-            Objects.requireNonNull( name, "Group name cannot be null." );
-            this.name = name;
-        }
-
-        public String name()
-        {
-            return name;
-        }
-
-        /**
-         * Name a new thread. This method may or may not be used, it is up to the scheduling strategy to decide
-         * to honor this.
-         */
-        public String threadName()
-        {
-            return "neo4j." + name() + "-" + threadCounter.incrementAndGet();
-        }
-
-        @Override
-        public boolean equals( Object o )
-        {
-            if ( this == o )
-            {
-                return true;
-            }
-            if ( o == null || getClass() != o.getClass() )
-            {
-                return false;
-            }
-
-            Group group = (Group) o;
-
-            return name.equals( group.name );
-        }
-
-        @Override
-        public int hashCode()
-        {
-            return name.hashCode();
-        }
-    }
-
     /**
      * This is an exhaustive list of job types that run in the database. It should be expanded as needed for new groups
      * of jobs.
@@ -242,31 +186,6 @@ private Groups()
         }
     }
 
-    interface JobHandle
-    {
-        void cancel( boolean mayInterruptIfRunning );
-
-        void waitTermination() throws InterruptedException, ExecutionException, CancellationException;
-
-        default void registerCancelListener( CancelListener listener )
-        {
-            throw new UnsupportedOperationException( "Unsupported in this implementation" );
-        }
-    }
-
-    /**
-     * Gets notified about calls to {@link JobHandle#cancel(boolean)}.
-     */
-    interface CancelListener
-    {
-        /**
-         * Notification that {@link JobHandle#cancel(boolean)} was called.
-         *
-         * @param mayInterruptIfRunning argument from {@link JobHandle#cancel(boolean)} call.
-         */
-        void cancelled( boolean mayInterruptIfRunning );
-    }
-
     /**
      * Assign a specific name to the top-most scheduler group.
      * <p>

community/community-it/index-it/src/test/java/org/neo4j/index/impl/lucene/explicit/NonUniqueIndexTest.java

@@ -52,6 +52,8 @@
 import org.neo4j.kernel.impl.logging.NullLogService;
 import org.neo4j.kernel.impl.scheduler.CentralJobScheduler;
 import org.neo4j.logging.LogProvider;
+import org.neo4j.scheduler.Group;
+import org.neo4j.scheduler.JobHandle;
 import org.neo4j.storageengine.api.schema.IndexReader;
 import org.neo4j.test.rule.PageCacheAndDependenciesRule;
 import org.neo4j.test.rule.fs.DefaultFileSystemRule;

community/index/src/test/java/org/neo4j/index/internal/gbptree/GroupingRecoveryCleanupWorkCollectorTest.java

@@ -27,6 +27,8 @@
 import java.util.List;
 
 import org.neo4j.helpers.Exceptions;
+import org.neo4j.scheduler.Group;
+import org.neo4j.scheduler.JobHandle;
 import org.neo4j.scheduler.JobSchedulerAdapter;
 
 import static org.junit.jupiter.api.Assertions.assertThrows;

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

@@ -22,6 +22,7 @@
 import java.util.concurrent.TimeUnit;
 
 import org.neo4j.kernel.lifecycle.LifecycleAdapter;
+import org.neo4j.scheduler.JobHandle;
 import org.neo4j.scheduler.JobScheduler;
 
 import static org.neo4j.scheduler.JobScheduler.Groups.transactionTimeoutMonitor;
@@ -31,7 +32,7 @@ public class KernelTransactionMonitorScheduler extends LifecycleAdapter
     private final KernelTransactionTimeoutMonitor kernelTransactionTimeoutMonitor;
     private final JobScheduler scheduler;
     private final long checkIntervalMillis;
-    private JobScheduler.JobHandle monitorJobHandle;
+    private JobHandle monitorJobHandle;
 
     public KernelTransactionMonitorScheduler( KernelTransactionTimeoutMonitor kernelTransactionTimeoutMonitor,
             JobScheduler scheduler, long checkIntervalMillis )

community/kernel/src/main/java/org/neo4j/kernel/impl/api/index/sampling/IndexSamplingController.java

@@ -31,7 +31,7 @@
 import org.neo4j.kernel.impl.api.index.IndexMapSnapshotProvider;
 import org.neo4j.kernel.impl.api.index.IndexProxy;
 import org.neo4j.scheduler.JobScheduler;
-import org.neo4j.scheduler.JobScheduler.JobHandle;
+import org.neo4j.scheduler.JobHandle;
 
 import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.neo4j.kernel.impl.api.index.sampling.IndexSamplingMode.BACKGROUND_REBUILD_UPDATED;

community/kernel/src/main/java/org/neo4j/kernel/impl/scheduler/CentralJobScheduler.java

@@ -31,6 +31,8 @@
 
 import org.neo4j.helpers.Exceptions;
 import org.neo4j.kernel.lifecycle.LifecycleAdapter;
+import org.neo4j.scheduler.Group;
+import org.neo4j.scheduler.JobHandle;
 import org.neo4j.scheduler.JobScheduler;
 import org.neo4j.time.Clocks;
 

community/kernel/src/main/java/org/neo4j/kernel/impl/scheduler/GroupedDaemonThreadFactory.java

@@ -24,14 +24,14 @@
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.atomic.AtomicReference;
 
-import org.neo4j.scheduler.JobScheduler;
+import org.neo4j.scheduler.Group;
 
 final class GroupedDaemonThreadFactory implements ThreadFactory, ForkJoinPool.ForkJoinWorkerThreadFactory
 {
-    private final JobScheduler.Group group;
+    private final Group group;
     private final ThreadGroup threadGroup;
 
-    GroupedDaemonThreadFactory( JobScheduler.Group group, ThreadGroup parentThreadGroup )
+    GroupedDaemonThreadFactory( Group group, ThreadGroup parentThreadGroup )
     {
         this.group = group;
         threadGroup = new ThreadGroup( parentThreadGroup, group.name() );

community/kernel/src/main/java/org/neo4j/kernel/impl/scheduler/PooledJobHandle.java

@@ -25,14 +25,15 @@
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
 
-import org.neo4j.scheduler.JobScheduler;
+import org.neo4j.scheduler.CancelListener;
+import org.neo4j.scheduler.JobHandle;
 
-final class PooledJobHandle implements JobScheduler.JobHandle
+final class PooledJobHandle implements JobHandle
 {
     private final Future<?> future;
     private final Object registryKey;
     private final ConcurrentHashMap<Object,Future<?>> registry;
-    private final List<JobScheduler.CancelListener> cancelListeners = new CopyOnWriteArrayList<>();
+    private final List<CancelListener> cancelListeners = new CopyOnWriteArrayList<>();
 
     PooledJobHandle( Future<?> future, Object registryKey, ConcurrentHashMap<Object,Future<?>> registry )
     {
@@ -45,7 +46,7 @@ final class PooledJobHandle implements JobScheduler.JobHandle
     public void cancel( boolean mayInterruptIfRunning )
     {
         future.cancel( mayInterruptIfRunning );
-        for ( JobScheduler.CancelListener cancelListener : cancelListeners )
+        for ( CancelListener cancelListener : cancelListeners )
         {
             cancelListener.cancelled( mayInterruptIfRunning );
         }
@@ -59,7 +60,7 @@ public void waitTermination() throws InterruptedException, ExecutionException
     }
 
     @Override
-    public void registerCancelListener( JobScheduler.CancelListener listener )
+    public void registerCancelListener( CancelListener listener )
     {
         cancelListeners.add( listener );
     }

community/kernel/src/main/java/org/neo4j/kernel/impl/scheduler/ScheduledJobHandle.java

@@ -24,9 +24,9 @@
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.atomic.AtomicInteger;
 
-import org.neo4j.scheduler.JobScheduler;
-import org.neo4j.scheduler.JobScheduler.CancelListener;
-import org.neo4j.scheduler.JobScheduler.JobHandle;
+import org.neo4j.scheduler.Group;
+import org.neo4j.scheduler.CancelListener;
+import org.neo4j.scheduler.JobHandle;
 import org.neo4j.util.concurrent.BinaryLatch;
 
 /**
@@ -62,14 +62,14 @@ final class ScheduledJobHandle extends AtomicInteger implements JobHandle
     //   or happens after the relevant handles have been added to the queue.
     long nextDeadlineNanos;
 
-    private final JobScheduler.Group group;
+    private final Group group;
     private final CopyOnWriteArrayList<CancelListener> cancelListeners;
     private final BinaryLatch handleRelease;
     private final Runnable task;
     private volatile JobHandle latestHandle;
     private volatile Throwable lastException;
 
-    ScheduledJobHandle( TimeBasedTaskScheduler scheduler, JobScheduler.Group group, Runnable task,
+    ScheduledJobHandle( TimeBasedTaskScheduler scheduler, Group group, Runnable task,
                         long nextDeadlineNanos, long reschedulingDelayNanos )
     {
         this.group = group;