diff options
Diffstat (limited to 'policy-core/src/main/java/org/onap/policy/drools/core/lock/Lock.java')
-rw-r--r-- | policy-core/src/main/java/org/onap/policy/drools/core/lock/Lock.java | 164 |
1 files changed, 43 insertions, 121 deletions
diff --git a/policy-core/src/main/java/org/onap/policy/drools/core/lock/Lock.java b/policy-core/src/main/java/org/onap/policy/drools/core/lock/Lock.java index de62b24a..b2ed9c7f 100644 --- a/policy-core/src/main/java/org/onap/policy/drools/core/lock/Lock.java +++ b/policy-core/src/main/java/org/onap/policy/drools/core/lock/Lock.java @@ -2,14 +2,14 @@ * ============LICENSE_START======================================================= * ONAP * ================================================================================ - * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved. + * Copyright (C) 2019 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. @@ -20,145 +20,67 @@ package org.onap.policy.drools.core.lock; -import java.util.Iterator; -import java.util.LinkedHashMap; -import java.util.Map.Entry; -import org.onap.policy.drools.utils.Pair; - /** - * Lock that is held for a resource. This not only identifies the current owner of the - * lock, but it also includes a queue of requesters. An item is associated with each - * requester that is waiting in the queue. Note: this class is <b>not</b> thread-safe. - * - * @param <T> type of item to be associated with a request + * Lock held on a resource. */ -public class Lock<T> { +public interface Lock { /** - * Result returned by <i>removeRequester()</i>. + * Frees/release the lock. + * + * <p/> + * Note: client code may choose to invoke this method <i>before</i> the lock has been + * granted. + * + * @return {@code true} if the request was accepted, {@code false} if the lock is + * unavailable */ - public enum RemoveResult { - /** - * The requester was the owner of the lock, and the lock is no longer needed, - * because there were no other requesters waiting to get the lock. - */ - UNLOCKED, - - /** - * The requester was the owner of the lock, and has been replaced with the next - * requester waiting in the queue. - */ - RELOCKED, - - /** - * The requester had been waiting in the queue, and has now been removed. - */ - REMOVED, - - /** - * The requester was not the owner, nor was it waiting in the queue. - */ - NOT_FOUND - } + boolean free(); /** - * The last owner to grab the lock, never {@code null}. + * Determines if the lock is active. + * + * @return {@code true} if the lock is <b>ACTIVE</b>, {@code false} otherwise */ - private String owner; + boolean isActive(); /** - * Requesters waiting to get the lock. Maps the requester (i.e., owner for which the - * request is being made) to its associated item. Uses a Linked map so that the order - * of the requesters is maintained. We don't expect many requesters for any given - * lock, thus we'll start with a small hash size. + * Determines if the lock is unavailable. Once a lock object becomes unavailable, it + * will never become active again. + * + * @return {@code true} if the lock is <b>UNAVAILABLE</b>, {@code false} otherwise */ - private LinkedHashMap<String, T> requester2item = new LinkedHashMap<>(5); + boolean isUnavailable(); /** - * Constructor. - * - * @param owner the current owner of this lock + * Determines if this object is waiting for a lock to be granted or denied. This + * applies when the lock is first created, or after {@link #extend(int, LockCallback)} + * has been invoked. + * + * @return {@code true} if the lock is <b>WAITING</b>, {@code false} otherwise */ - public Lock(String owner) { - this.owner = owner; - } + boolean isWaiting(); /** - * Get owner. - * - * @return the current owner of the lock, or the last owner of the lock, if the lock - * is not currently owned. (This will never be {@code null}.) + * Gets the ID of the resource to which the lock applies. + * + * @return the ID of the resource to which the lock applies */ - public String getOwner() { - return owner; - } + String getResourceId(); /** - * Adds a new requester to the queue of requesters. - * - * @param requester the requester - * @param item to be associated with the requester, must not be {@code null} - * @return {@code true} if the requester was added, {@code false} if it already owns - * the lock or is already in the queue - * @throws IllegalArgumentException if the item is null + * Gets the lock's owner key. + * + * @return the lock's owner key */ - public boolean add(String requester, T item) { - if (item == null) { - throw SimpleLockManager.makeNullArgException("lock requester item is null"); - } - - if (requester.equals(owner)) { - // requester already owns the lock - return false; - } - - T prev = requester2item.putIfAbsent(requester, item); - - // if there's a previous value, then that means this requester is already - // waiting for a lock on this resource. In that case, we return false - return (prev == null); - } + String getOwnerKey(); /** - * Removes a requester from the lock. The requester may currently own the lock, or it - * may be in the queue waiting for the lock. Note: as this is agnostic to the type of - * item associated with the requester, it is unable to notify the new owner that it's - * the new owner; that is left up to the code that invokes this method. - * - * @param requester the requester - * @param newOwner the new owner info is placed here, if the result is <i>RELOCKED</i> - * @return the result + * Extends a lock an additional amount of time from now. The callback will always be + * invoked, and may be invoked <i>before</i> this method returns. + * + * @param holdSec the additional amount of time to hold the lock, in seconds + * @param callback callback to be invoked when the extension completes */ - public RemoveResult removeRequester(String requester, Pair<String, T> newOwner) { - - if (!requester.equals(owner)) { - // requester does not currently own the lock - remove it from the - // queue - T ent = requester2item.remove(requester); - - // if there was an entry in the queue, then return true to indicate - // that it was removed. Otherwise, return false - return (ent != null ? RemoveResult.REMOVED : RemoveResult.NOT_FOUND); - } - - /* - * requester was the owner - find something to take over - */ - Iterator<Entry<String, T>> it = requester2item.entrySet().iterator(); - if (!it.hasNext()) { - // no one to take over the lock - it's now unlocked - return RemoveResult.UNLOCKED; - } - - // there's another requester to take over - Entry<String, T> ent = it.next(); - it.remove(); - - owner = ent.getKey(); - - newOwner.first(owner); - newOwner.second(ent.getValue()); - - return RemoveResult.RELOCKED; - } + void extend(int holdSec, LockCallback callback); } |