Cleanup of the Locks interfaces

- Remove variadic APIs, as they are not used and have broken semantics
- HA protocol remains the same (eg. allows grabbing multiple locks in one req)
- Remove releaseAllShared and releaseAllExclusive, as they were not used
- Don't insert exclusivelock after aquiring an update lock, no reason to
- Don't print own id in waitlist

community/kernel/src/main/java/org/neo4j/kernel/api/Locking.java

@@ -23,9 +23,9 @@
 
 public interface Locking
 {
-    void acquireExclusive( ResourceType type, long ... id );
-    void acquireShared(    ResourceType type, long ... id );
+    void acquireExclusive( ResourceType type, long id );
+    void acquireShared(    ResourceType type, long id );
 
-    void releaseExclusive( ResourceType type, long ... id );
-    void releaseShared(    ResourceType type, long ... id );
+    void releaseExclusive( ResourceType type, long id );
+    void releaseShared(    ResourceType type, long id );
 }

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

@@ -370,25 +370,25 @@ public Property graphRemoveProperty( KernelStatement state, int propertyKeyId )
     }
 
     @Override
-    public void acquireExclusive( KernelStatement state, Locks.ResourceType resourceType, long[] resourceId )
+    public void acquireExclusive( KernelStatement state, Locks.ResourceType resourceType, long resourceId )
     {
         state.locks().acquireExclusive( resourceType, resourceId );
     }
 
     @Override
-    public void acquireShared(KernelStatement state, Locks.ResourceType resourceType, long[] resourceId )
+    public void acquireShared(KernelStatement state, Locks.ResourceType resourceType, long resourceId )
     {
         state.locks().acquireShared( resourceType, resourceId );
     }
 
     @Override
-    public void releaseExclusive( KernelStatement state, Locks.ResourceType type, long[] resourceId )
+    public void releaseExclusive( KernelStatement state, Locks.ResourceType type, long resourceId )
     {
         state.locks().releaseExclusive( type, resourceId );
     }
 
     @Override
-    public void releaseShared( KernelStatement state, Locks.ResourceType type, long[] resourceId )
+    public void releaseShared( KernelStatement state, Locks.ResourceType type, long resourceId )
     {
         state.locks().releaseShared( type, resourceId );
     }

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

@@ -787,28 +787,28 @@ public void uniqueIndexDrop( IndexDescriptor descriptor ) throws DropIndexFailur
 
     // <Locking>
     @Override
-    public void acquireExclusive( Locks.ResourceType type, long... id )
+    public void acquireExclusive( Locks.ResourceType type, long id )
     {
         statement.assertOpen();
         locking().acquireExclusive( statement, type, id );
     }
 
     @Override
-    public void acquireShared( Locks.ResourceType type, long... id )
+    public void acquireShared( Locks.ResourceType type, long id )
     {
         statement.assertOpen();
         locking().acquireShared( statement, type, id );
     }
 
     @Override
-    public void releaseExclusive( Locks.ResourceType type, long... id )
+    public void releaseExclusive( Locks.ResourceType type, long id )
     {
         statement.assertOpen();
         locking().releaseExclusive( statement, type, id );
     }
 
     @Override
-    public void releaseShared( Locks.ResourceType type, long... id )
+    public void releaseShared( Locks.ResourceType type, long id )
     {
         statement.assertOpen();
         locking().releaseShared( statement, type, id );

community/kernel/src/main/java/org/neo4j/kernel/impl/api/operations/LockOperations.java

@@ -24,9 +24,9 @@
 
 public interface LockOperations
 {
-    void acquireExclusive( KernelStatement state, Locks.ResourceType resourceType, long[] resourceId );
-    void acquireShared( KernelStatement state, Locks.ResourceType resourceType, long[] resourceId );
+    void acquireExclusive( KernelStatement state, Locks.ResourceType resourceType, long resourceId );
+    void acquireShared( KernelStatement state, Locks.ResourceType resourceType, long resourceId );
 
-    void releaseExclusive( KernelStatement statement, Locks.ResourceType type, long[] id );
-    void releaseShared( KernelStatement statement, Locks.ResourceType type, long[] id );
+    void releaseExclusive( KernelStatement statement, Locks.ResourceType type, long id );
+    void releaseShared( KernelStatement statement, Locks.ResourceType type, long id );
 }

community/kernel/src/main/java/org/neo4j/kernel/impl/locking/Locks.java

@@ -44,7 +44,7 @@
  */
 public interface Locks extends Lifecycle
 {
-    public abstract class Factory extends Service
+    abstract class Factory extends Service
     {
         public Factory( String key, String... altKeys )
         {
@@ -55,14 +55,14 @@ public Factory( String key, String... altKeys )
     }
 
     /** For introspection and debugging. */
-    public interface Visitor
+    interface Visitor
     {
         /** Visit the description of a lock held by at least one client. */
         void visit( ResourceType resourceType, long resourceId, String description, long estimatedWaitTime );
     }
 
     /** Locks are split by resource types. It is up to the implementation to define the contract for these. */
-    public interface ResourceType
+    interface ResourceType
     {
         /** Must be unique among all existing resource types, should preferably be a sequence starting at 0. */
         int typeId();
@@ -71,38 +71,32 @@ public interface ResourceType
         WaitStrategy waitStrategy();
     }
 
-    public interface Client extends AutoCloseable
+    interface Client extends AutoCloseable
     {
         /**
          * Can be grabbed when there are no locks or only share locks on a resource. If the lock cannot be acquired,
          * behavior is specified by the {@link WaitStrategy} for the given {@link ResourceType}.
          */
-        void acquireShared(ResourceType resourceType, long ... resourceIds) throws AcquireLockTimeoutException;
+        void acquireShared( ResourceType resourceType, long resourceId ) throws AcquireLockTimeoutException;
 
         /**
          * Can be grabbed when no other client holds locks on the relevant resources. No other clients can hold locks
          * while one client holds an exclusive lock. If the lock cannot be acquired,
          * behavior is specified by the {@link WaitStrategy} for the given {@link ResourceType}.
          */
-        void acquireExclusive(ResourceType resourceType, long ... resourceIds) throws AcquireLockTimeoutException;
+        void acquireExclusive( ResourceType resourceType, long resourceId ) throws AcquireLockTimeoutException;
 
         /** Try grabbing exclusive lock, not waiting and returning a boolean indicating if we got the lock. */
-        boolean tryExclusiveLock( ResourceType resourceType, long ... resourceIds );
+        boolean tryExclusiveLock( ResourceType resourceType, long resourceId );
 
         /** Try grabbing shared lock, not waiting and returning a boolean indicating if we got the lock. */
-        boolean trySharedLock( ResourceType resourceType, long ... resourceIds );
+        boolean trySharedLock( ResourceType resourceType, long resourceId );
 
         /** Release a set of shared locks */
-        void releaseShared( ResourceType resourceType, long... resourceIds );
+        void releaseShared( ResourceType resourceType, long resourceId );
 
         /** Release a set of exclusive locks */
-        void releaseExclusive( ResourceType resourceType, long... resourceIds );
-
-        /** Release all shared locks. */
-        void releaseAllShared();
-
-        /** Release all exclusive locks. */
-        void releaseAllExclusive();
+        void releaseExclusive( ResourceType resourceType, long resourceId );
 
         /** Release all locks. */
         void releaseAll();

community/kernel/src/main/java/org/neo4j/kernel/impl/locking/NoOpClient.java

@@ -22,45 +22,39 @@
 public class NoOpClient implements Locks.Client
 {
     @Override
-    public void acquireShared( Locks.ResourceType resourceType, long... resourceIds ) throws AcquireLockTimeoutException
+    public void acquireShared( Locks.ResourceType resourceType, long resourceId ) throws AcquireLockTimeoutException
     {
+
     }
 
     @Override
-    public void acquireExclusive( Locks.ResourceType resourceType, long... resourceIds ) throws AcquireLockTimeoutException
+    public void acquireExclusive( Locks.ResourceType resourceType, long resourceId ) throws AcquireLockTimeoutException
     {
+
     }
 
     @Override
-    public boolean tryExclusiveLock( Locks.ResourceType resourceType, long... resourceIds )
+    public boolean tryExclusiveLock( Locks.ResourceType resourceType, long resourceId )
     {
         return false;
     }
 
     @Override
-    public boolean trySharedLock( Locks.ResourceType resourceType, long... resourceIds )
+    public boolean trySharedLock( Locks.ResourceType resourceType, long resourceId )
     {
         return false;
     }
 
     @Override
-    public void releaseShared( Locks.ResourceType resourceType, long... resourceIds )
+    public void releaseShared( Locks.ResourceType resourceType, long resourceId )
     {
-    }
 
-    @Override
-    public void releaseExclusive( Locks.ResourceType resourceType, long... resourceIds )
-    {
     }
 
     @Override
-    public void releaseAllShared()
+    public void releaseExclusive( Locks.ResourceType resourceType, long resourceId )
     {
-    }
 
-    @Override
-    public void releaseAllExclusive()
-    {
     }
 
     @Override