appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/test/java/org/openecomp/appc/lockmanager/impl/sql/optimistic/TestMySqlLockManager.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP : APPC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Copyright (C) 2017 Amdocs
   8  * =============================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  22  * ============LICENSE_END=========================================================
  23  */
  24
  25 package org.onap.appc.lockmanager.impl.sql.optimistic;
  26
  27 import org.junit.Assert;
  28 import org.junit.Test;
  29 import org.onap.appc.lockmanager.api.LockException;
  30 import org.onap.appc.lockmanager.impl.sql.JdbcLockManager;
  31 import org.onap.appc.lockmanager.impl.sql.MySqlLockManagerBaseTests;
  32 import org.onap.appc.lockmanager.impl.sql.Synchronizer;
  33
  34 import java.util.concurrent.*;
  35
  36 public class TestMySqlLockManager extends MySqlLockManagerBaseTests {
  37
  38         @Override
  39         protected JdbcLockManager createJdbcLockManager(boolean useReal) {
  40                 return new MySqlLockManagerMock(useReal);
  41         }
  42
  43         @Test
  44         public void testConcurrentLockDifferentOwners() throws LockException, InterruptedException, ExecutionException, TimeoutException {
  45
  46                 final int participantsNo = 2;
  47                 Synchronizer synchronizer = new Synchronizer(participantsNo) {
  48
  49                         private boolean wait = true;
  50
  51                         @Override
  52                         public void preAddLockRecord(String resource, String owner) {
  53                                 if(Owner.A.name().equals(owner)) {
  54                                         synchronized(this) {
  55                                                 if(wait) {
  56                                                         waitOn(this);
  57                                                 }
  58                                         }
  59                                 }
  60                         }
  61
  62                         @Override
  63                         public void postAddLockRecord(String resource, String owner) {
  64                                 if(!Owner.A.name().equals(owner)) {
  65                                         synchronized(this) {
  66                                                 notifyAll();
  67                                                 wait = false;
  68                                         }
  69                                 }
  70                         }
  71
  72                         @Override
  73                         public void preUpdateLockRecord(String resource, String owner) {
  74                                 preAddLockRecord(resource, owner);
  75                         }
  76
  77                         @Override
  78                         public void postUpdateLockRecord(String resource, String owner) {
  79                                 postAddLockRecord(resource, owner);
  80                         }
  81                 };
  82                 if(!setSynchronizer(synchronizer)) {
  83                         return;
  84                 }
  85                 ExecutorService executor = Executors.newFixedThreadPool(participantsNo);
  86                 // acquireLock by owner A should fail as it will wait for acquireLock by owner B
  87                 Future<Boolean> future1 = executor.submit(new Callable<Boolean>() {
  88                         @Override
  89                         public Boolean call() throws Exception {
  90                                 try {
  91                                         lockManager.acquireLock(Resource.Resource1.name(), Owner.A.name());
  92                                         return false;
  93                                 } catch(LockException e) {
  94                                         // this call should fail as Synchronizer delays its lock to make sure the second call locks the resource first
  95                                         Assert.assertEquals("Cannot lock resource [" + Resource.Resource1.name() + "] for [" + Owner.A.name() + "]: already locked by [" + Owner.B.name() + "]", e.getMessage());
  96                                         return true;
  97                                 }
  98                         }
  99                 });
 100                 try {
 101                         // acquireLock by owner B should success
 102                         Future<Boolean> future2 = executor.submit(new Callable<Boolean>() {
 103                                 @Override
 104                                 public Boolean call() throws Exception {
 105                                         // this call should success as Synchronizer delays the above lock to make sure this call success to lock the resource
 106                                         return lockManager.acquireLock(Resource.Resource1.name(), Owner.B.name());
 107                                 }
 108                         });
 109                         try {
 110                                 Assert.assertTrue(future2.get(CONCURRENT_TEST_WAIT_TIME, TimeUnit.SECONDS));
 111                                 Assert.assertTrue(future1.get(CONCURRENT_TEST_WAIT_TIME, TimeUnit.SECONDS));
 112                         } finally {
 113                                 future2.cancel(true);
 114                         }
 115                 } finally {
 116                         future1.cancel(true);
 117                 }
 118         }
 119
 120         @Test
 121         public void testConcurrentLockSameOwner() throws LockException, InterruptedException, ExecutionException, TimeoutException {
 122                 final int participantsNo = 2;
 123                 Synchronizer synchronizer = new Synchronizer(participantsNo) {
 124
 125                         private boolean wait = true;
 126
 127                         @Override
 128                         public void preAddLockRecord(String resource, String owner) {
 129                                 synchronized(this) {
 130                                         if(wait) {
 131                                                 wait = false;
 132                                                 waitOn(this);
 133                                         }
 134                                 }
 135                         }
 136
 137                         @Override
 138                         public void postAddLockRecord(String resource, String owner) {
 139                                 synchronized(this) {
 140                                         notifyAll();
 141                                 }
 142                         }
 143                 };
 144                 if(!setSynchronizer(synchronizer)) {
 145                         return;
 146                 }
 147                 ExecutorService executor = Executors.newFixedThreadPool(participantsNo);
 148                 // one acquireLock should return true and the other should return false
 149                 Callable<Boolean> callable = new Callable<Boolean>() {
 150                         @Override
 151                         public Boolean call() throws Exception {
 152                                 return lockManager.acquireLock(Resource.Resource1.name(), Owner.A.name());
 153                         }
 154                 };
 155                 Future<Boolean> future1 = executor.submit(callable);
 156                 try {
 157                         Future<Boolean> future2 = executor.submit(callable);
 158                         try {
 159                                 boolean future1Res = future1.get(CONCURRENT_TEST_WAIT_TIME, TimeUnit.SECONDS);
 160                                 boolean future2Res = future2.get(CONCURRENT_TEST_WAIT_TIME, TimeUnit.SECONDS);
 161                                 // one of the lock requests should return true, the other one false as lock is requested simultaneously from 2 threads by same owner
 162                                 Assert.assertNotEquals(future1Res, future2Res);
 163                         } finally {
 164                                 future2.cancel(true);
 165                         }
 166                 } finally {
 167                         future1.cancel(true);
 168                 }
 169         }
 170
 171         @Test
 172         public void testConcurrentUnlockSameOwner() throws LockException, InterruptedException, ExecutionException, TimeoutException {
 173                 lockManager.acquireLock(Resource.Resource1.name(), Owner.A.name());
 174                 final int participantsNo = 2;
 175                 Synchronizer synchronizer = new Synchronizer(participantsNo) {
 176
 177                         private boolean wait = true;
 178
 179                         @Override
 180                         public void preUpdateLockRecord(String resource, String owner) {
 181                                 synchronized(this) {
 182                                         // make sure second call updates the LockRecord first
 183                                         if(wait) {
 184                                                 wait = false;
 185                                                 waitOn(this);
 186                                         }
 187                                 }
 188                         }
 189
 190                         @Override
 191                         public void postUpdateLockRecord(String resource, String owner) {
 192                                 synchronized(this) {
 193                                         notifyAll();
 194                                 }
 195                         }
 196                 };
 197                 if(!setSynchronizer(synchronizer)) {
 198                         return;
 199                 }
 200                 ExecutorService executor = Executors.newFixedThreadPool(participantsNo);
 201                 Callable<Boolean> callable = new Callable<Boolean>() {
 202                         @Override
 203                         public Boolean call() throws Exception {
 204                                 try {
 205                                         lockManager.releaseLock(Resource.Resource1.name(), Owner.A.name());
 206                                         // one of the unlock calls should success
 207                                         return true;
 208                                 } catch(LockException e) {
 209                                         // one of the unlock calls should throw the LockException as the resource should already be unlocked by other call
 210                                         Assert.assertEquals("Error unlocking resource [" + Resource.Resource1.name() + "]: resource is not locked", e.getMessage());
 211                                         return false;
 212                                 }
 213                         }
 214                 };
 215                 Future<Boolean> future1 = executor.submit(callable);
 216                 try {
 217                         Future<Boolean> future2 = executor.submit(callable);
 218                         try {
 219                                 boolean future1Res = future1.get(CONCURRENT_TEST_WAIT_TIME, TimeUnit.SECONDS);
 220                                 boolean future2Res = future2.get(CONCURRENT_TEST_WAIT_TIME, TimeUnit.SECONDS);
 221                                 // one of the unlock calls should return true, the other one false as unlock is requested simultaneously from 2 threads by same owner
 222                                 Assert.assertNotEquals(future1Res, future2Res);
 223                         } finally {
 224                                 future2.cancel(true);
 225                         }
 226                 } finally {
 227                         future1.cancel(true);
 228                 }
 229         }
 230 }