diff options
Diffstat (limited to 'controlloop/m2/lock')
3 files changed, 316 insertions, 0 deletions
diff --git a/controlloop/m2/lock/pom.xml b/controlloop/m2/lock/pom.xml new file mode 100644 index 000000000..00ea2a84c --- /dev/null +++ b/controlloop/m2/lock/pom.xml @@ -0,0 +1,55 @@ +<?xml version="1.0"?> +<!-- + ============LICENSE_START======================================================= + ONAP Policy Engine - Drools PDP + ================================================================================ + Copyright (C) 2020 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. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ============LICENSE_END========================================================= + --> + +<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> + <modelVersion>4.0.0</modelVersion> + <parent> + <artifactId>m2</artifactId> + <groupId>org.onap.policy.drools-applications.controlloop.m2</groupId> + <version>1.6.0-SNAPSHOT</version> + </parent> + + <artifactId>lock</artifactId> + <name>lock</name> + <description>Generic Lock used for Locking Target Entities</description> + + <dependencies> + <dependency> + <groupId>org.onap.policy.drools-applications.controlloop.m2</groupId> + <artifactId>base</artifactId> + <version>${project.version}</version> + </dependency> + + <dependency> + <groupId>org.onap.policy.drools-pdp</groupId> + <artifactId>policy-management</artifactId> + <version>${version.policy.drools-pdp}</version> + <scope>provided</scope> + </dependency> + + <dependency> + <groupId>junit</groupId> + <artifactId>junit</artifactId> + <scope>test</scope> + </dependency> + </dependencies> + +</project> diff --git a/controlloop/m2/lock/src/main/java/org/onap/policy/drools/m2/lock/LockAdjunct.java b/controlloop/m2/lock/src/main/java/org/onap/policy/drools/m2/lock/LockAdjunct.java new file mode 100644 index 000000000..e81ab6288 --- /dev/null +++ b/controlloop/m2/lock/src/main/java/org/onap/policy/drools/m2/lock/LockAdjunct.java @@ -0,0 +1,164 @@ +/*- + * ============LICENSE_START======================================================= + * m2/lock + * ================================================================================ + * Copyright (C) 2020 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.drools.m2.lock; + +import java.io.Serializable; +import java.util.HashMap; + +import org.onap.policy.drools.core.lock.Lock; +import org.onap.policy.drools.core.lock.LockCallback; +import org.onap.policy.drools.system.PolicyEngineConstants; +import org.onap.policy.m2.base.Transaction; + +/* + * Adjunct data placed within the transaction, to contain locks + * on control loop use case basis. This same instance is shared + * among all actor operation instances within the transaction + * regardless of what actor is in the policy chain. As a result, + * the lock gets passed from one to the next, and is only freed + * when the transaction completes. + */ +public class LockAdjunct implements Transaction.Adjunct, LockCallback, + Serializable { + private static final long serialVersionUID = 1L; + + /** + * This is the callback interface, which is only used if the lock is + * initially not available, and we end up waiting for it. + */ + public interface Requestor { + /** + * This method is called once the lock has been acquired. + */ + void lockAvailable(); + + /** + * This method is called to notify the requestor that the lock could not + * be obtained. + */ + void lockUnavailable(); + } + + // lock associated with all of the AOTS and SDNR operations + // within the transaction + private Lock lock = null; + + // the initial requestor of the lock + // (only set if we don't immediately acquire the lock) + private Requestor requestor = null; + + /** + * allocate a lock on behalf of the requestor. + * + * @param requestor + * the AOTS or SDNR operation requesting the lock + * @param key + * string key identifying the lock + * @param ownerKey + * string key identifying the owner + * @param waitForLock + * used to determine if an operation should wait for a lock to + * become available or fail immediately + * @return 'true' if we immediately acquired the lock, 'false' if the lock + * is currently in use by another transaction, and we need to wait + */ + public boolean getLock(Requestor requestor, String key, String ownerKey, + boolean waitForLock) { + if (lock != null) { + if (lock.isActive()) { + // we already have an active lock + return true; + } + + // We may have timed out earlier waiting for the lock, or + // we may have lost the lock after persistent restore. In + // any case, free the lock we have now, and allocate a new one. + lock.free(); + } + + // register the requestor in case the lockUnavailable() callback runs + // immediately. Previously the requestor would be set after the + // lock constructor ran but now the lockUnavailable() callback + // could be executed while the constructor is still on the stack which + // would result in a null requestor, thus the callback never + // notifying the requestor that the lock was unavailable. + this.requestor = requestor; + + // try to allocate a new lock + if ((lock = PolicyEngineConstants.getManager().createLock( + key, ownerKey, 600, this, waitForLock)).isActive()) { + // the lock is good + return true; + } + + // we need to wait for the lock -- return false, + return false; + } + + /*=================================*/ + /* 'Transaction.Adjunct' interface */ + /*=================================*/ + + /** + * Notification that the transaction has completed. + * + * {@inheritDoc} + */ + @Override + public void cleanup(Transaction transaction) { + if (lock != null) { + // free the lock or cancel the reservation + lock.free(); + } + } + + /*==========================*/ + /* 'LockCallback' interface */ + /*==========================*/ + + /** + * Notification that the lock is available. + * + * {@inheritDoc} + */ + @Override + public void lockAvailable(Lock lock) { + this.lock = lock; + if (requestor != null) { + // notify requestor + requestor.lockAvailable(); + } + } + + /** + * Notification that the lock is not available. + * + * {@inheritDoc} + */ + @Override + public void lockUnavailable(Lock lock) { + this.lock = lock; + if (requestor != null) { + // notify requestor + requestor.lockUnavailable(); + } + } +} diff --git a/controlloop/m2/lock/src/test/java/org/onap/policy/drools/m2/lock/LockAdjunctTest.java b/controlloop/m2/lock/src/test/java/org/onap/policy/drools/m2/lock/LockAdjunctTest.java new file mode 100644 index 000000000..4c5770fb2 --- /dev/null +++ b/controlloop/m2/lock/src/test/java/org/onap/policy/drools/m2/lock/LockAdjunctTest.java @@ -0,0 +1,97 @@ +/*- + * ============LICENSE_START======================================================= + * m2/lock + * ================================================================================ + * Copyright (C) 2020 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.drools.m2.lock; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import java.util.Properties; +import java.util.UUID; + +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; + +import org.onap.policy.drools.core.lock.Lock; +import org.onap.policy.drools.core.lock.LockCallback; +import org.onap.policy.drools.system.PolicyEngineConstants; +import org.onap.policy.m2.base.Transaction; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class LockAdjunctTest { + + private static Logger logger = LoggerFactory.getLogger(LockAdjunctTest.class); + + public class TestOwner implements LockCallback { + + @Override + public void lockAvailable(Lock arg0) { + return; + } + + @Override + public void lockUnavailable(Lock arg0) { + return; + } + } + + private LockCallback owner; + private Lock lock; + + @BeforeClass + public static void start() { + PolicyEngineConstants.getManager().configure(new Properties()); + PolicyEngineConstants.getManager().start(); + } + + @AfterClass + public static void stop() { + PolicyEngineConstants.getManager().stop(); + } + + @Test + public void lockAdjunctTest() { + owner = new TestOwner(); + lock = PolicyEngineConstants.getManager().createLock("key", "ownerKey", 60, owner, false); + LockAdjunct lockA = new LockAdjunct(); + + assertNotNull(lockA); + + lockA.lockUnavailable(lock); + assertTrue(lock.isActive()); + assertTrue(lockA.getLock(null, "key", "ownerKey", false)); + LockAdjunct lockB = new LockAdjunct(); + assertFalse(lockB.getLock(null, "key", "ownerKey", false)); + assertTrue(lock.free()); + + lockB.lockAvailable(lock); + assertFalse(lock.isActive()); + assertTrue(lockB.getLock(null, "key", "ownerKey", false)); + assertFalse(lock.free()); + + UUID uuid = UUID.randomUUID(); + Transaction transaction = new Transaction(null, "1111", uuid, null); + lockA.cleanup(transaction); + } +} |