* ============LICENSE_START=======================================================
* guard
* ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
package org.onap.policy.guard;
import java.util.UUID;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
import org.onap.policy.controlloop.policy.TargetType;
import org.onap.policy.drools.core.lock.PolicyResourceLockManager;
import org.onap.policy.guard.impl.PNFTargetLock;
* @param targetInstance the target instance
* @param requestID the request Id
* @param callback the LockCallback
+ * @param holdSec maximum number of seconds to hold the lock
* @return the LockResult
* @throws IllegalArgumentException if an argument is null
*/
public static LockResult<GuardResult, TargetLock> lockTarget(TargetType targetType, String targetInstance,
- UUID requestID, LockCallback callback) {
+ UUID requestID, LockCallback callback, int holdSec) {
String owner = makeOwner(targetType, requestID);
- GuardResult guardResult = managerLockTarget(targetInstance, owner);
+ GuardResult guardResult = managerLockTarget(targetInstance, owner, holdSec);
if(guardResult != GuardResult.LOCK_ACQUIRED) {
return LockResult.createLockResult(guardResult, null);
}
logger.debug("Locked {}", lock);
return LockResult.createLockResult(GuardResult.LOCK_ACQUIRED, lock);
}
+
+ /**
+ * Extends a lock on a target.
+ * @param lock current lock
+ * @param holdSec maximum number of seconds to hold the lock
+ * @return the result: acquired or denied
+ */
+ public static GuardResult lockTarget(TargetLock lock, int holdSec) {
+ String owner = makeOwner(lock.getTargetType(), lock.getRequestID());
+ GuardResult result = managerLockTarget(lock.getTargetInstance(), owner, holdSec);
+
+ logger.debug("Lock {} extend {}", lock, result);
+ return result;
+ }
/**
* Asks the manager to lock the given target.
* @param targetInstance
* @param owner
- * @return the result: acquired, denied, or exception
+ * @param holdSec maximum number of seconds to hold the lock
+ * @return the result: acquired or denied
*/
- private static GuardResult managerLockTarget(String targetInstance, String owner) {
- try {
- Future<Boolean> result = factory.getManager().lock(targetInstance, owner, null);
- return(result.get() ? GuardResult.LOCK_ACQUIRED : GuardResult.LOCK_DENIED);
-
- } catch(IllegalStateException e) {
- logger.warn("{} attempted to re-lock {}", owner, targetInstance);
- return GuardResult.LOCK_DENIED;
-
- } catch (InterruptedException e) {
- logger.error("exception getting lock for {}", targetInstance, e);
- Thread.currentThread().interrupt();
- return GuardResult.LOCK_EXCEPTION;
-
- } catch (ExecutionException e) {
- logger.error("exception getting lock for {}", targetInstance, e);
- return GuardResult.LOCK_EXCEPTION;
- }
+ private static GuardResult managerLockTarget(String targetInstance, String owner, int holdSec) {
+ boolean result = factory.getManager().lock(targetInstance, owner, holdSec);
+ return(result ? GuardResult.LOCK_ACQUIRED : GuardResult.LOCK_DENIED);
}
/**
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.doThrow;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.UUID;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
public class PolicyGuardTest {
private static final String INSTANCENAME = "targetInstance";
+ private static final int LOCK_SEC = 10;
private static Factory saveFactory;
// Test isLocked before and after lock added
assertFalse(PolicyGuard.isLocked(type, INSTANCENAME, uuid));
- LockResult<GuardResult, TargetLock> result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid, dlcb);
+ LockResult<GuardResult, TargetLock> result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid, dlcb, LOCK_SEC);
assertTrue(PolicyGuard.isLocked(type, INSTANCENAME, uuid));
assertEquals(GuardResult.LOCK_ACQUIRED, result.getA());
// Test isLocked before and after lock added
assertFalse(PolicyGuard.isLocked(type, INSTANCENAME, uuid));
- LockResult<GuardResult, TargetLock> result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid, dlcb);
+ LockResult<GuardResult, TargetLock> result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid, dlcb, LOCK_SEC);
assertTrue(PolicyGuard.isLocked(type, INSTANCENAME, uuid));
assertEquals(GuardResult.LOCK_ACQUIRED, result.getA());
// Test isLocked before and after lock added
assertFalse(PolicyGuard.isLocked(type, INSTANCENAME, uuid));
- LockResult<GuardResult, TargetLock> result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid, dlcb);
+ LockResult<GuardResult, TargetLock> result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid, dlcb, LOCK_SEC);
assertTrue(PolicyGuard.isLocked(type, INSTANCENAME, uuid));
assertEquals(GuardResult.LOCK_ACQUIRED, result.getA());
// Test isLocked before and after lock added
assertFalse(PolicyGuard.isLocked(type, INSTANCENAME, uuid));
- LockResult<GuardResult, TargetLock> result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid, dlcb);
+ LockResult<GuardResult, TargetLock> result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid, dlcb, LOCK_SEC);
assertFalse(PolicyGuard.isLocked(type, INSTANCENAME, uuid));
assertEquals(GuardResult.LOCK_EXCEPTION, result.getA());
// Test isLocked before and after lock added
assertFalse(PolicyGuard.isLocked(type, INSTANCENAME, uuid));
- LockResult<GuardResult, TargetLock> result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid, dlcb);
+ LockResult<GuardResult, TargetLock> result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid, dlcb, LOCK_SEC);
assertTrue(PolicyGuard.isLocked(type, INSTANCENAME, uuid));
assertEquals(GuardResult.LOCK_ACQUIRED, result.getA());
assertEquals(VMTargetLock.class, result.getB().getClass());
- result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid, dlcb);
- assertTrue(PolicyGuard.isLocked(type, INSTANCENAME, uuid));
-
- assertEquals(GuardResult.LOCK_DENIED, result.getA());
- assertNull(result.getB());
-
// Test isLocked after lock removed
PolicyGuard.unlockTarget(new DummyTargetLock(type, uuid));
assertFalse(PolicyGuard.isLocked(type, INSTANCENAME, uuid));
// Test isLocked before and after lock added
assertFalse(PolicyGuard.isLocked(type, INSTANCENAME, uuid));
- LockResult<GuardResult, TargetLock> result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid, dlcb);
+ LockResult<GuardResult, TargetLock> result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid, dlcb, LOCK_SEC);
assertTrue(PolicyGuard.isLocked(type, INSTANCENAME, uuid));
assertEquals(GuardResult.LOCK_ACQUIRED, result.getA());
assertEquals(VMTargetLock.class, result.getB().getClass());
- result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid, dlcb);
+ UUID uuid2 = UUID.randomUUID();
+ result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid2, dlcb, LOCK_SEC);
+ assertFalse(PolicyGuard.isLocked(type, INSTANCENAME, uuid2));
+
assertTrue(PolicyGuard.isLocked(type, INSTANCENAME, uuid));
assertEquals(GuardResult.LOCK_DENIED, result.getA());
public void testManagerLockTarget() throws Exception {
TargetType type = TargetType.VM;
- @SuppressWarnings("unchecked")
- Future<Boolean> fut = mock(Future.class);
-
mgr = mock(PolicyResourceLockManager.class);
- when(mgr.lock(any(), any(), any())).thenReturn(fut);
LockResult<GuardResult, TargetLock> result;
// acquired
- when(fut.get()).thenReturn(true);
- result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid, dlcb);
+ when(mgr.lock(anyString(), anyString(), anyInt())).thenReturn(true);
+ result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid, dlcb, LOCK_SEC);
+ verify(mgr).lock(INSTANCENAME, type.toString()+":"+uuid.toString(), LOCK_SEC);
assertEquals(GuardResult.LOCK_ACQUIRED, result.getA());
assertEquals(VMTargetLock.class, result.getB().getClass());
// denied
- when(fut.get()).thenReturn(false);
- result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid, dlcb);
+ when(mgr.lock(anyString(), anyString(), anyInt())).thenReturn(false);
+ result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid, dlcb, LOCK_SEC+2);
+ verify(mgr).lock(INSTANCENAME, type.toString()+":"+uuid.toString(), LOCK_SEC+2);
assertEquals(GuardResult.LOCK_DENIED, result.getA());
assertNull(result.getB());
+ }
- // illegal state exception
- doThrow(new IllegalStateException("state expected")).when(fut).get();
- result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid, dlcb);
- assertEquals(GuardResult.LOCK_DENIED, result.getA());
- assertNull(result.getB());
- assertFalse(Thread.currentThread().isInterrupted());
+ @Test
+ public void testManagerLockTargetTargetLockInt() throws Exception {
+ TargetType type = TargetType.VM;
+ DummyTargetLock lock = new DummyTargetLock(type, uuid);
+
+ mgr = mock(PolicyResourceLockManager.class);
- // interrupted exception
- doThrow(new InterruptedException("interrupt expected")).when(fut).get();
- result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid, dlcb);
- assertEquals(GuardResult.LOCK_EXCEPTION, result.getA());
- assertNull(result.getB());
- // verify interrupted & reset interrupt status
- assertTrue(Thread.interrupted());
+ // acquired
+ when(mgr.lock(anyString(), anyString(), anyInt())).thenReturn(true);
+ assertEquals(GuardResult.LOCK_ACQUIRED, PolicyGuard.lockTarget(lock, LOCK_SEC));
+ verify(mgr).lock(INSTANCENAME, type.toString()+":"+uuid.toString(), LOCK_SEC);
- // exec exception
- doThrow(new ExecutionException(new IllegalArgumentException("exec expected"))).when(fut).get();
- result = PolicyGuard.lockTarget(type, INSTANCENAME, uuid, dlcb);
- assertEquals(GuardResult.LOCK_EXCEPTION, result.getA());
- assertNull(result.getB());
- assertFalse(Thread.currentThread().isInterrupted());
+ // denied
+ when(mgr.lock(anyString(), anyString(), anyInt())).thenReturn(false);
+ assertEquals(GuardResult.LOCK_DENIED, PolicyGuard.lockTarget(lock, LOCK_SEC+1));
+ verify(mgr).lock(INSTANCENAME, type.toString()+":"+uuid.toString(), LOCK_SEC+1);
}
@Test(expected = IllegalArgumentException.class)