You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@river.apache.org by pe...@apache.org on 2020/07/05 11:41:42 UTC
svn commit: r1879521 [27/37] - in
/river/jtsk/modules/modularize/apache-river: ./ browser/
browser/src/main/java/org/apache/river/example/browser/ extra/
groovy-config/ river-activation/ river-collections/
river-collections/src/main/java/org/apache/riv...
Modified: river/jtsk/modules/modularize/apache-river/river-services/outrigger/outrigger-service/src/main/java/org/apache/river/outrigger/EntryHolder.java
URL: http://svn.apache.org/viewvc/river/jtsk/modules/modularize/apache-river/river-services/outrigger/outrigger-service/src/main/java/org/apache/river/outrigger/EntryHolder.java?rev=1879521&r1=1879520&r2=1879521&view=diff
==============================================================================
--- river/jtsk/modules/modularize/apache-river/river-services/outrigger/outrigger-service/src/main/java/org/apache/river/outrigger/EntryHolder.java (original)
+++ river/jtsk/modules/modularize/apache-river/river-services/outrigger/outrigger-service/src/main/java/org/apache/river/outrigger/EntryHolder.java Sun Jul 5 11:41:39 2020
@@ -1,842 +1,845 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you 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.
- */
-package org.apache.river.outrigger;
-
-import java.util.Hashtable;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Queue;
-import java.util.Set;
-import java.util.WeakHashMap;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.ConcurrentMap;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import net.jini.core.entry.UnusableEntryException;
-import net.jini.core.transaction.CannotJoinException;
-import net.jini.core.transaction.server.TransactionConstants;
-import net.jini.id.Uuid;
-
-/**
- * <code>EntryHolder</code>s hold all the entries of a exact given
- * class. <code>OutriggerServerImpl</code> has one
- * <code>EntryHolder</code> for each entry class it knows about. A
- * simple implementation is used that simply stores the entries in a
- * list.
- *
- * @author Sun Microsystems, Inc.
- */
-class EntryHolder implements TransactionConstants {
- /** The list that holds the handles */
-// private final FastList<EntryHandle> contents = new FastList<EntryHandle>();
-
- private final Queue<EntryHandle> content = new ConcurrentLinkedQueue<EntryHandle>();
-
- /**
- * The map of cookies to handles, shared with the
- * <code>EntryHolderSet</code> and every other
- * <code>EntryHolder</code>.
- */
- private final ConcurrentMap<Uuid, EntryHandle> idMap;
-
- /** The server we are working for */
- private final OutriggerServerImpl space;
-
- /** Logger for logging information about entry matching */
- private static final Logger matchingLogger =
- Logger.getLogger(OutriggerServerImpl.matchingLoggerName);
-
- /** Logger for logging information about iterators */
- private static final Logger iteratorLogger =
- Logger.getLogger(OutriggerServerImpl.iteratorLoggerName);
-
- /**
- * Create a new <code>EntryHolder</code> with the shared
- * <code>idMap</code>, and which will hold classes of the given
- * <code>className</code>. The <code>idMap</code> is shared with
- * <code>EntryHolderSet</code> so that there is one table that can
- * map ID to <code>EntryRep</code>
- */
- EntryHolder(OutriggerServerImpl space, ConcurrentMap<Uuid,EntryHandle> idMap) {
- this.space = space;
- this.idMap = idMap;
- }
-
- EntryHandle newEntryHandle(EntryRep rep, TransactableMgr mgr){
- return new EntryHandle(rep, mgr, this, content);
- }
-
- /**
- * Return an <code>EntryHandle</code> object that matches the given
- * template, or <code>null</code> if none does. Optionally
- * removes (perhaps provisionally) the found entry.
- *
- * @param tmpl The template to match against
- * @param txn If non-null the transaction (represented as
- * a <code>TransactableMgr</code> to perform
- * the operation under. May be <code>null</code>
- * if the operation is not to be done under
- * a transaction.
- * @param takeIt <code>true</code> if <code>hasMatch</code> should
- * remove the matching entry.
- * @param conflictSet If non-null the <code>TransactableMgr</code>
- * objects of any transactions that prevent
- * a non-null value from being retured will
- * be added to <code>conflictSet</code>. May
- * be <code>null</code> in which case
- * conflicting transaction will not be recorded.
- * This method assumes that any concurrent access
- * is being arbitrated by the set or by the caller.
- * @param lockedEntrySet If non-null the ID of any entries that
- * can't be retured because of conflicting
- * transaction will be added to
- * <code>lockedEntrySet</code>. May be
- * <code>null</code> in which case unavailable
- * entries will not be recorded. This method
- * assumes that any concurrent access is being
- * arbitrated by the set or by the caller.
- * @param provisionallyRemovedEntrySet If the entry can not be
- * read/taken because it has been provisionally
- * removed then its handle will be placed in the
- * passed <code>WeakHashMap</code> as a key (with
- * null as the value). May be <code>null</code> in
- * which case provisionally removed entries will not
- * be recorded. This method assumes that any
- * concurrent access is being arbitrated by the set
- * or by the caller.
- * @throws CannotJoinException if a match is found and
- * the operation is to be performed under a transaction,
- * but the transaction is no longer active.
- * @see #attemptCapture
- */
- EntryHandle hasMatch(EntryRep tmpl, TransactableMgr txn, boolean takeIt,
- Set conflictSet, Set lockedEntrySet,
- Set provisionallyRemovedEntrySet)
- throws CannotJoinException {
- matchingLogger.entering("EntryHolder", "hasMatch");
- EntryHandleTmplDesc desc = null;
- long startTime = 0;
-
- for (EntryHandle handle : content) {
-
- if (startTime == 0) {
- // First time through
- desc = EntryHandle.descFor(tmpl, handle.rep().numFields());
- startTime = System.currentTimeMillis();
- }
-
- if (handle.removed())
- continue;
-
- // Quick reject -- see the if handle mask is incompatible
- if ((handle.hash() & desc.mask) != desc.hash)
- continue;
-
- final EntryRep rep = handle.rep();
-
- if (!tmpl.matches(rep))
- continue;
-
- final boolean available = confirmAvailabilityWithTxn(rep, handle,
- txn, takeIt, startTime, conflictSet, lockedEntrySet,
- provisionallyRemovedEntrySet);
-
- if (available)
- return handle;
- }
-
- return null;
- }
-
-
- /**
- * Debug method: Dump out the state of this holder, printing out
- * the name of the dump first.
- */
- void dump(String name) {
- try {
- System.out.println(name);
- for (EntryHandle handle : content)
- {
- EntryRep rep = handle.rep();
- System.out.println(" " + rep + ", " + rep.entry());
- }
- } catch (UnusableEntryException e) {
- e.printStackTrace();
- }
- }
-
- /**
- * Atomically check to see if the passed entry can be read/taken by
- * the specified operation using the specified transaction and if
- * it can read/take it and return <code>true</code>, otherwise
- * return <code>false</code>. If the entry is removed. Note,
- * if the entry is removed, removal is logged.
- * @param handle The <code>EntryHandle</code> of the entry
- * the caller wants to read/take.
- * @param txn If non-null the transaction to perform
- * this operation under. Note, if non-null and
- * <code>txn</code> is not active <code>false</code>
- * will be returned.
- * @param takeIt <code>true</code> if the caller is trying
- * take the passed entry, <code>false</code>
- * otherwise.
- * @param conflictSet If non-null and the entry can not be
- * read/taken because of transaction conflicts the
- * conflicting transaction(s) will be added to this set.
- * This method assumes that any concurrent access is
- * being arbitrated by the set or by the caller.
- * @param lockedEntrySet If the entry can not be read/taken
- * because of a transaction conflict, the ID of the
- * entry will be added to this set. This method
- * assumes that any concurrent access is being arbitrated
- * by the set or by the caller.
- * @param provisionallyRemovedEntrySet If the entry can not be
- * read/taken because it has been provisionally
- * removed then its handle will be placed in the
- * passed <code>WeakHashMap</code> as a key (with
- * null as the value). May be <code>null</code> in
- * which case provisionally removed entries will not
- * be recorded. This method assumes that any
- * concurrent access is being arbitrated by the set
- * or by the caller.
- * @param now an estimate of the current time in milliseconds
- * since the beginning of the epoch.
- * @return <code>true</code> if the entry could be read/taken and
- * <code>false</code> otherwise.
- * @throws NullPointerException if entry is <code>null</code>.
- */
- boolean attemptCapture(EntryHandle handle, TransactableMgr txn,
- boolean takeIt, Set conflictSet, Set lockedEntrySet,
- Set provisionallyRemovedEntrySet, long now)
- {
- try {
- return confirmAvailabilityWithTxn(handle.rep(), handle,
- txn, takeIt, now, conflictSet, lockedEntrySet,
- provisionallyRemovedEntrySet);
- } catch (CannotJoinException e) {
- return false;
- }
- }
-
- /* Now that we know we have a match, make sure that the the
- * item in question is still in the space and hasn't been
- * subject to other transactional-interference...
- */
- private boolean confirmAvailabilityWithTxn(EntryRep rep,
- EntryHandle handle, TransactableMgr txnMgr, boolean takeIt,
- long time, Set conflictSet, Set<Uuid> lockedEntrySet,
- Set<EntryHandle> provisionallyRemovedEntrySet)
- throws CannotJoinException
- {
- // Now that we know we have a match, make sure that the the
- // item in question is still in the space and hasn't been
- // subject to other transactional-interference...
-
- // Lock the txn first (since that what everybody else does that)
- // to ensure that the locking always happens in A cannonical
- // order. We lock the transaction (txn) object to ensure that the
- // transaction hasn't been altered behind our backs. Other, cheaper
- // actions with the space (write, etc.) are handled nicely in
- // OutriggerServerImpl. But, this one (reading/taking) was expensive
- // enough that we wanted to do it here, where the window is
- // smallest.
- // Bug 4394263...
-
- final Txn txn = (Txn)txnMgr;
- try {
- if (txn != null)
- txn.ensureActive();
-
- return confirmAvailability(rep, handle, txn,
- takeIt, time, conflictSet, lockedEntrySet,
- provisionallyRemovedEntrySet);
- } finally {
- if (txn != null)
- txn.allowStateChange();
- }
- }
-
- /**
- * With the EntryRep <code>rep</code> passed in, verify that the
- * entry hasn't been taken by someone else, hasn't expired, etc.
- * Also, verify that the entry is really (legally) visible to this
- * transaction at this time. If this is a <code>take</code>, it it
- * is removed or provisionally removed. If this operation is under
- * a transaction, the entry is locked appropriately.
- */
- // @see grab -- a helper routine
- private boolean
- confirmAvailability(EntryRep rep, EntryHandle handle,
- TransactableMgr txn, boolean takeIt, long time,
- Set conflictSet, Set<Uuid> lockedEntrySet,
- Set<EntryHandle> provisionallyRemovedEntrySet)
- {
- synchronized (handle) {
- if (handle.removed()) return false;
- // get rid of stale entries
- if (isExpired(time, handle))
- return false;
-
- if (handle.isProvisionallyRemoved()) {
- if (provisionallyRemovedEntrySet != null)
- provisionallyRemovedEntrySet.add(handle);
- return false;
- }
-
- int op = (takeIt ? TransactableMgr.TAKE : TransactableMgr.READ);
- if (!handle.canPerform(txn, op)) {
- // Before deciding this is a conflict, we have to
- // make sure we are not conflicting with ourselves.
- if (handle.onlyMgr(txn))
- // We are just conflicting with ourselves, this entry
- // must have been taken by this txn already ... oh well
- return false;
-
- // Must be a real conflict, log if we were told too
- if (matchingLogger.isLoggable(Level.FINER)) {
- matchingLogger.log(Level.FINER, "match, but can''t " +
- "perform {0}; handle.knownMgr(txn) == {1}",
- new Object[] {Integer.valueOf(op),
- Boolean.valueOf(handle.knownMgr(txn))});
- }
-
- if (conflictSet != null) {
- handle.addTxns(conflictSet);
- }
-
- if (lockedEntrySet != null) {
- lockedEntrySet.add(rep.id());
- }
-
- return false;
- }
-
- if (grab(handle, txn, op, takeIt, false))
- return true;
- else
- throw
- new AssertionError("entry became non-available while locked");
- }
- }
-
- /**
- * Given an entry that we want to return as the result of a query
- * and we have confirmed we can return it, make the results of the
- * query visible to the rest of the service. We must either [a]
- * remove it from the holder (if the operation is a take under the
- * same transaction the entry was written under), [b] mark it as
- * provisionally removed pending commiting the operation to disk
- * (if the operation is a take without a transaction), [c]
- * lock it under the transaction passed into this method (if the
- * operation is a read or take under a transaction), or [d] do
- * nothing (read not under a transaction) as appropriate.
- * <p>
- * Also used during log recovery to recover takes.
- *
- * @param handle The handle attached to the particular EntryRep
- * @param txn The Txn object
- * @param op TAKE or READ (as a TransactableMgr constant)
- * @param takeIt Is this a TAKE (or is it [false] a READ)
- * @param recovery <code>true</code> if being called as
- * part of store recovery.
- * @return <code>true</code> if the entry could be grabbed.
- * @throws NullPointerException if <code>handle</code> is
- * <code>null</code>.
- */
- private boolean grab(EntryHandle handle, TransactableMgr txn, int op,
- boolean takeIt, boolean recovery)
- {
- assert op==(takeIt?TransactableMgr.TAKE:TransactableMgr.READ);
- assert !recovery || takeIt;
-
- /*
- * If this manager (txn) is known to the handle, then txn
- * is a transaction which can operate directly on the
- * existing handle. If so, then we can operate on it
- * directly. Note that if txn is null and the handle is
- * not managed, then txn is "known" in this sense.
- *
- * Else, this operation is new relative to the
- * known transactions (possibly null) and txn.
- */
-
- if (handle.knownMgr(txn)) { // added or read in this txn if taking
- // take it if we have to (otherwise it must be a read
- // there is no house keeping to be done since must already
- // be read locked)
-
- if (takeIt) {
- // is this an entry that was written under this
- // transaction or another?
-
- if (handle.managed()) {
- // It is locked by a transaction and it must
- // be the one this take is under.
-
- if (!handle.promoteToTakeIfNeeded()) {
- // this transaction wrote the entry (note txn
- // must be non-null, otherwise either
- // handle.managed or handle.knownMgr(txn)
- // would have returned null), just need to try
- // and remove it
- assert txn != null;
-
- // It is ok to call remove before committing this
- // op to disk since a crash will cause the original
- // write to be undone and the entry will still
- // end up being removed.
- if (!remove(handle, recovery))
- // Someone got to it first
- return false;
- }
-
- // Otherwise it was read locked (now take
- // locked and needs to still be semi-visible
- // to ifExists queries outside of the
- // transaction, leave it in place with its new
- // lock type (aka "state")
-
- } else {
- // Nether the entry nor this take are under a
- // transaction (txn must be null because the
- // that is the only way knownMgr return true, and
- // managed() false)
- assert txn == null;
- synchronized (handle){
- if (handle.removed() || handle.isProvisionallyRemoved())
- // Someone got to it first
- return false;
- handle.provisionallyRemove();
- }
- }
- }
- } else {
- if (txn != null) {
- // We need to add this txn to this handle and
- // add this handle to this txn.
- handle.add(txn, op, this); // add manager to handle's list
- txn.add(handle); // add handle to mgr's list
- }
- }
- return true;
- }
-
- /**
- * Recover a logged take.
- * @param handle The <code>EntryHandle</code> of the entry who's
- * take is being logged.
- * @param txn If non-null the transaction the take was performed
- * under.
- * @throws NullPointerException if <code>handle</code> is
- * <code>null</code>.
- */
- void recoverTake(EntryHandle handle, Txn txn) {
- if (!grab(handle, txn, TransactableMgr.TAKE, true, true))
- throw
- new AssertionError("match not found while recovering take");
- }
-
-
- /**
- * Return <code>true</code> if the entry held by the given
- * <code>handle</code> has expired by the time in <code>now</code>.
- */
- private boolean isExpired(long now, EntryHandle handle) {
- /* Some callers already own the lock on handle when
- * they call us, but the general feeling is that
- * re-synchronizing is not costly and it is important
- * to only call remove if we own the lock.
- */
- synchronized (handle) {
- final EntryRep rep = handle.rep();
- synchronized (rep) {
- if (rep.getExpiration() > now) {
- // Not expired
- return false;
- }
-
- /* Expired, set expiration to before the beginning of
- * time so renew() (which does not lock on the handle,
- * but the rep...) can't renew the lease once we leave
- * this block, even it already has a ref to the
- * rep. Everyone else locks on the handle so
- * and makes sure the handle has not been removed
- * before doing anything important.
- */
- rep.setExpiration(Long.MIN_VALUE);
- }
-
- // If we are here the lease must have expired
- if (matchingLogger.isLoggable(Level.FINER)) {
- matchingLogger.log(Level.FINER, "expired {0} at {1} (now {2})",
- new Object[] {rep.id(),
- Long.valueOf(rep.getExpiration()),
- Long.valueOf(now)});
- }
-
- if (!handle.isProvisionallyRemoved() && remove(handle, false)) {
- /* If we got to do the remove, schedule
- * logging of the removal, otherwise
- * someone else already did it, or will do it
- */
- space.scheduleCancelOp(rep.id());
- }
-
- return true;
- }
- }
-
- /**
- * Get the head of the contents list
- * @return The head of the contents list, if it exists.
- * null if the list is empty.
- */
- private EntryHandle getContentsHead(){
- return content.peek();
- }
-
- /**
- * Add new new entry to the holder. Assumes the lock
- * on the handle is held if there is a possibility
- * of concurrent access.
- * @param handle The <code>EntryHandle</code> for the
- * entry being added.
- * @param txn If the add is being done under a
- * transaction the <code>TransactableMgr</code> for
- * that transaction.
- * @throws NullPointerException if <code>handle</code> is
- * <code>null</code>.
- */
- void add(EntryHandle handle, TransactableMgr txn) {
- final EntryRep rep = handle.rep();
-
- /* Make sure info duplicated across all the handles in this
- * holder is shared.
- *
- * We make the head call before calling txn.add because
- * it seems like better hygiene to fix reps state before
- * exposing it to others (even though shareWith will
- * not change handle's state materially).
- */
- final EntryHandle head = getContentsHead();
- if (head != null && head != handle) rep.shareWith(head.rep());
- synchronized (handle){ //typically synchronized externally anyway.
- if (txn != null) txn.add(handle);
- content.add(handle);
- EntryHandle existed = idMap.putIfAbsent(rep.getCookie(), handle);
- if (existed != null) throw new IllegalStateException("An EntryHandle with that Cookie already exists in idMap");
- }
- }
-
- /**
- * Return an array of the class names of the super classes of the
- * entries in this holder, or <code>null</code> if the holder is
- * empty.
- */
- String[] supertypes() {
- final EntryHandle head = getContentsHead();
- if (head == null)
- return null;
- return head.rep().superclasses();
- }
-
- /**
- * Return an enumerator over the contents of this space that are visible
- * from the given mgr.
- */
- RepEnum contents(TransactableMgr mgr) {
- return new SimpleRepEnum(mgr);
- }
-
- /**
- * The class that implements <code>RepEnum</code> for this class.
- */
- private class SimpleRepEnum implements RepEnum {
- private final Iterator<EntryHandle> contentsIterator;
- private final TransactableMgr mgr;
- private final long startTime;
-
- SimpleRepEnum(TransactableMgr mgr) {
- this.mgr = mgr;
- startTime = System.currentTimeMillis();
- contentsIterator = content.iterator();
- }
-
- // inherit doc comment from superclass
- public EntryRep nextRep() {
- iteratorLogger.entering("SimpleRepEnum", "nextRep");
- while (contentsIterator.hasNext()) {
- EntryHandle handle = contentsIterator.next();
- iteratorLogger.log(Level.FINEST,
- "advanced current handle to {0}", handle);
- /*
- * Skip over handles which are either removed or unable to
- * perform a READ operation.
- */
- synchronized (handle){
- if (handle.canPerform(mgr, TransactableMgr.READ)
- && !isExpired(startTime, handle) && !handle.removed()) {
- return handle.rep();
- }
- }
-
- }
-
- return null;
- }
- }
-
-
- /**
- * Return an object that can be used to perform a query that can
- * return multiple matches and be restarted in another thread.
- *
- * @param tmpls An array of templates. Query will yield any
- * entry that matches one or more of the templates.
- * @param txn Transaction that should be used with the query.
- * May be <code>null</code>. If
- * non-<code>null</code> any entries yielded by the
- * query will be locked under the transaction.
- * @param takeThem If <code>true</code> any entries yielded by
- * the query should be removed.
- * @param now Estimate of current time used to weed out
- * expired entries, ok if old
- * @return a new ContinuingQuery object.
- */
- ContinuingQuery continuingQuery(EntryRep[] tmpls, TransactableMgr txn,
- boolean takeThem, long now)
- {
- return new ContinuingQuery(tmpls, txn, takeThem, now);
- }
-
- /**
- * Object that can be used to perform a query that can
- * return multiple matches and be restarted in another thread.
- * Assumes that is being invoked from only one thread
- * at a time, but does handle synchronization between concurrent
- * queries on the parent <code>EntryHolder</code>.
- */
- class ContinuingQuery {
- /** Templates being used for the query */
- final private EntryRep[] tmpls;
-
- /** Transaction (if any) being used for the query */
- final private TransactableMgr txn;
-
- /**
- * <code>true</code> if entries yielded by the query should
- * removed.
- */
- final private boolean takeThem;
-
- /** <code>EntryHandleTmplDesc</code> for the templates */
- final private ThreadLocal<EntryHandleTmplDesc[]> descLocal;
-
-
- /** Time used to weed out expired entries, ok if old */
- volatile long now;
-
- /**
- * Current position in parent <code>EntryHolder</code>'s
- * <code>contents</code>
- */
- private final Iterator<EntryHandle> contentsIterator;
-
- /**
- * Create a new <code>ContinuingQuery</code> object.
- *
- * @param tmpls An array of templates. Query will yield any
- * entry that matches one or more of the templates.
- * @param txn Transaction that should be used with the query.
- * May be <code>null</code>. If
- * non-<code>null</code> any entries yielded by the
- * query will be locked under the transaction.
- * @param takeThem If <code>true</code> any entries yielded by
- * the query should be removed.
- * @param now Estimate of current time used to weed out
- * expired entries, ok if old
- */
- // * @return a new ContinuingQuery object. (?)
- private ContinuingQuery(EntryRep[] tmpls, TransactableMgr txn,
- boolean takeThem, long now)
- {
- this.tmpls = tmpls;
- this.txn = txn;
- this.takeThem = takeThem;
- this.now = now;
- contentsIterator = content.iterator();
- descLocal = new ThreadLocal<EntryHandleTmplDesc[]>();
- }
-
- /**
- * <code>EntryHolder</code> queries have thread local state
- * that get clobbered if another query (on a different or same
- * <code>EntryHolder</code>, including <code>hasMatch</code>
- * calls) is started in the same thread. The state also needs
- * to be restored if it the query is continued in another
- * thread. The <code>restart</code> method must be called to
- * restore the thread local state.
- * @param now Estimate of current time used to weed out
- * expired entries, ok if old
- */
- void restart(long now) {
- if (!contentsIterator.hasNext()) return;
- this.now = now;
- }
-
- /**
- * Return the next matching entry. Returns <code>null</code>
- * if there are no matches remaining. Call {@link #restart
- * restart} first if query is being used in a different thread
- * from the last <code>next</code> call and/or the current
- * thread has done any form of <code>EntryHolder</code> query
- * on any holder since the last next call.
- *
- * @param conflictSet If non-null the <code>TransactableMgr</code>
- * objects of any transactions that prevent
- * a entry from being retured will
- * be added to <code>conflictSet</code>. May
- * be <code>null</code> in which case
- * conflicting transaction will not be recorded.
- * This method assumes that any concurrent access
- * is being arbitrated by the set or by the caller.
- * @param lockedEntrySet If non-null the ID of any entries that
- * can't be retured because of conflicting
- * transaction will be added to
- * <code>lockedEntrySet</code>. May be
- * <code>null</code> in which case unavailable
- * entries will not be recorded. This method
- * assumes that any concurrent access is being
- * arbitrated by the set or by the caller.
- * @param provisionallyRemovedEntrySet If the entry can not be
- * read/taken because it has been provisionally
- * removed then its handle will be placed in the
- * passed <code>WeakHashMap</code> as a key (with
- * null as the value). May be <code>null</code> in
- * which case provisionally removed entries will not
- * be recorded. This method assumes that any
- * concurrent access is being arbitrated by the set
- * or by the caller.
- * @return a matching entry or <code>null</code>.
- * @throws CannotJoinException if a match is found and
- * the operation is to be performed under a transaction,
- * but the transaction is no longer active.
- */
- EntryHandle next(Set conflictSet, Set<Uuid> lockedEntrySet, Set<EntryHandle> provisionallyRemovedEntrySet)
- throws CannotJoinException
- {
- matchingLogger.entering("ContinuingQuery", "next");
- EntryHandleTmplDesc[] descs = descLocal.get();
- while (contentsIterator.hasNext()) {
- EntryHandle handle = contentsIterator.next();
- if(descs == null){
- // first time
- descs = new EntryHandleTmplDesc[tmpls.length];
- for (int i=0; i<tmpls.length; i++) {
- descs[i] = EntryHandle.descFor(tmpls[i],
- handle.rep().numFields());
- }
- descLocal.set(descs);
- }
- if (handleMatch(handle, descs)) {
- final boolean available =
- confirmAvailabilityWithTxn(handle.rep(), handle, txn,
- takeThem, now, conflictSet, lockedEntrySet,
- provisionallyRemovedEntrySet);
-
- if (available) return handle;
- }
- }
-
- return null;
- }
-
- /**
- * Returns <code>true</code> if handle has not been removed
- * and matches one or more of the templates
- */
- private boolean handleMatch(EntryHandle handle, EntryHandleTmplDesc[] descs) {
- if (handle.removed()) return false;
- int length = tmpls.length;
- for (int i=0; i<length; i++) {
- final EntryRep tmpl = tmpls[i];
- final EntryHandleTmplDesc desc = descs[i];
-
- // Quick reject
- if ((handle.hash() & desc.mask) != desc.hash)
- continue;
- if (!tmpl.matches(handle.rep()))
- continue;
- return true;
- }
-
- return false;
- }
- }
-
- /**
- * Remove the given handle from this holder and the <code>idMap</code>.
- * If the handle isn't in this holder, this does nothing.
- * @param h the <code>EntryHandle</code> to remove.
- * @param recovery <code>true</code> if being called as part
- * of log recovery.
- * @return <code>true</code> if this call removed <code>h</code> and
- * <code>false</code> otherwise.
- */
- boolean remove(EntryHandle h, boolean recovery) {
- boolean ok = false;
- synchronized (h){
- ok = h.remove();
- if (!ok) throw new AssertionError("EntryHandle not removed");
- h.removalComplete();
- // Ensure removal of EntryHandle is atomic.
- boolean removed = idMap.remove(h.rep().getCookie(), h);
- if (!removed) throw new IllegalStateException ("EntryHandle was missing from idMap at time of removal");
- /* This may cause an ifExists query to be resolved,
- * even if this entry was not locked under a transaction
- */
- if (!recovery) {
- space.recordTransition(
- new EntryTransition(h, null, false, false, false));
- }
- }
- return ok;
- }
-
- /**
- * Reap the expired elements.
- */
- void reap() {
-
- // Examine each of the elements to determine if
- // any of them have expired. If they have, ensure that they are
- // removed ("reaped") from the collection.
-
- long now = System.currentTimeMillis();
- for(EntryHandle handle : content){
- // Don't try to remove things twice
- if (handle.removed()) continue;
- // Calling isExpired() will both make the check and remove it
- // if necessary.
- isExpired(now, handle);
- }
- }
-}
-
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ */
+package org.apache.river.outrigger;
+
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+import java.util.WeakHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ConcurrentMap;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import net.jini.core.entry.UnusableEntryException;
+import net.jini.core.transaction.CannotJoinException;
+import net.jini.core.transaction.server.TransactionConstants;
+import net.jini.id.Uuid;
+
+import org.apache.river.outrigger.proxy.EntryRep;
+
+
+/**
+ * <code>EntryHolder</code>s hold all the entries of a exact given
+ * class. <code>OutriggerServerImpl</code> has one
+ * <code>EntryHolder</code> for each entry class it knows about. A
+ * simple implementation is used that simply stores the entries in a
+ * list.
+ *
+ * @author Sun Microsystems, Inc.
+ */
+class EntryHolder implements TransactionConstants {
+ /** The list that holds the handles */
+// private final FastList<EntryHandle> contents = new FastList<EntryHandle>();
+
+ private final Queue<EntryHandle> content = new ConcurrentLinkedQueue<EntryHandle>();
+
+ /**
+ * The map of cookies to handles, shared with the
+ * <code>EntryHolderSet</code> and every other
+ * <code>EntryHolder</code>.
+ */
+ private final ConcurrentMap<Uuid, EntryHandle> idMap;
+
+ /** The server we are working for */
+ private final OutriggerServerImpl space;
+
+ /** Logger for logging information about entry matching */
+ private static final Logger matchingLogger =
+ Logger.getLogger(OutriggerServerImpl.matchingLoggerName);
+
+ /** Logger for logging information about iterators */
+ private static final Logger iteratorLogger =
+ Logger.getLogger(OutriggerServerImpl.iteratorLoggerName);
+
+ /**
+ * Create a new <code>EntryHolder</code> with the shared
+ * <code>idMap</code>, and which will hold classes of the given
+ * <code>className</code>. The <code>idMap</code> is shared with
+ * <code>EntryHolderSet</code> so that there is one table that can
+ * map ID to <code>EntryRep</code>
+ */
+ EntryHolder(OutriggerServerImpl space, ConcurrentMap<Uuid,EntryHandle> idMap) {
+ this.space = space;
+ this.idMap = idMap;
+ }
+
+ EntryHandle newEntryHandle(EntryRep rep, TransactableMgr mgr){
+ return new EntryHandle(rep, mgr, this, content);
+ }
+
+ /**
+ * Return an <code>EntryHandle</code> object that matches the given
+ * template, or <code>null</code> if none does. Optionally
+ * removes (perhaps provisionally) the found entry.
+ *
+ * @param tmpl The template to match against
+ * @param txn If non-null the transaction (represented as
+ * a <code>TransactableMgr</code> to perform
+ * the operation under. May be <code>null</code>
+ * if the operation is not to be done under
+ * a transaction.
+ * @param takeIt <code>true</code> if <code>hasMatch</code> should
+ * remove the matching entry.
+ * @param conflictSet If non-null the <code>TransactableMgr</code>
+ * objects of any transactions that prevent
+ * a non-null value from being retured will
+ * be added to <code>conflictSet</code>. May
+ * be <code>null</code> in which case
+ * conflicting transaction will not be recorded.
+ * This method assumes that any concurrent access
+ * is being arbitrated by the set or by the caller.
+ * @param lockedEntrySet If non-null the ID of any entries that
+ * can't be retured because of conflicting
+ * transaction will be added to
+ * <code>lockedEntrySet</code>. May be
+ * <code>null</code> in which case unavailable
+ * entries will not be recorded. This method
+ * assumes that any concurrent access is being
+ * arbitrated by the set or by the caller.
+ * @param provisionallyRemovedEntrySet If the entry can not be
+ * read/taken because it has been provisionally
+ * removed then its handle will be placed in the
+ * passed <code>WeakHashMap</code> as a key (with
+ * null as the value). May be <code>null</code> in
+ * which case provisionally removed entries will not
+ * be recorded. This method assumes that any
+ * concurrent access is being arbitrated by the set
+ * or by the caller.
+ * @throws CannotJoinException if a match is found and
+ * the operation is to be performed under a transaction,
+ * but the transaction is no longer active.
+ * @see #attemptCapture
+ */
+ EntryHandle hasMatch(EntryRep tmpl, TransactableMgr txn, boolean takeIt,
+ Set conflictSet, Set lockedEntrySet,
+ Set provisionallyRemovedEntrySet)
+ throws CannotJoinException {
+ matchingLogger.entering("EntryHolder", "hasMatch");
+ EntryHandleTmplDesc desc = null;
+ long startTime = 0;
+
+ for (EntryHandle handle : content) {
+
+ if (startTime == 0) {
+ // First time through
+ desc = EntryHandle.descFor(tmpl, handle.rep().numFields());
+ startTime = System.currentTimeMillis();
+ }
+
+ if (handle.removed())
+ continue;
+
+ // Quick reject -- see the if handle mask is incompatible
+ if ((handle.hash() & desc.mask) != desc.hash)
+ continue;
+
+ final EntryRep rep = handle.rep();
+
+ if (!tmpl.matches(rep))
+ continue;
+
+ final boolean available = confirmAvailabilityWithTxn(rep, handle,
+ txn, takeIt, startTime, conflictSet, lockedEntrySet,
+ provisionallyRemovedEntrySet);
+
+ if (available)
+ return handle;
+ }
+
+ return null;
+ }
+
+
+ /**
+ * Debug method: Dump out the state of this holder, printing out
+ * the name of the dump first.
+ */
+ void dump(String name) {
+ try {
+ System.out.println(name);
+ for (EntryHandle handle : content)
+ {
+ EntryRep rep = handle.rep();
+ System.out.println(" " + rep + ", " + rep.entry());
+ }
+ } catch (UnusableEntryException e) {
+ e.printStackTrace();
+ }
+ }
+
+ /**
+ * Atomically check to see if the passed entry can be read/taken by
+ * the specified operation using the specified transaction and if
+ * it can read/take it and return <code>true</code>, otherwise
+ * return <code>false</code>. If the entry is removed. Note,
+ * if the entry is removed, removal is logged.
+ * @param handle The <code>EntryHandle</code> of the entry
+ * the caller wants to read/take.
+ * @param txn If non-null the transaction to perform
+ * this operation under. Note, if non-null and
+ * <code>txn</code> is not active <code>false</code>
+ * will be returned.
+ * @param takeIt <code>true</code> if the caller is trying
+ * take the passed entry, <code>false</code>
+ * otherwise.
+ * @param conflictSet If non-null and the entry can not be
+ * read/taken because of transaction conflicts the
+ * conflicting transaction(s) will be added to this set.
+ * This method assumes that any concurrent access is
+ * being arbitrated by the set or by the caller.
+ * @param lockedEntrySet If the entry can not be read/taken
+ * because of a transaction conflict, the ID of the
+ * entry will be added to this set. This method
+ * assumes that any concurrent access is being arbitrated
+ * by the set or by the caller.
+ * @param provisionallyRemovedEntrySet If the entry can not be
+ * read/taken because it has been provisionally
+ * removed then its handle will be placed in the
+ * passed <code>WeakHashMap</code> as a key (with
+ * null as the value). May be <code>null</code> in
+ * which case provisionally removed entries will not
+ * be recorded. This method assumes that any
+ * concurrent access is being arbitrated by the set
+ * or by the caller.
+ * @param now an estimate of the current time in milliseconds
+ * since the beginning of the epoch.
+ * @return <code>true</code> if the entry could be read/taken and
+ * <code>false</code> otherwise.
+ * @throws NullPointerException if entry is <code>null</code>.
+ */
+ boolean attemptCapture(EntryHandle handle, TransactableMgr txn,
+ boolean takeIt, Set conflictSet, Set lockedEntrySet,
+ Set provisionallyRemovedEntrySet, long now)
+ {
+ try {
+ return confirmAvailabilityWithTxn(handle.rep(), handle,
+ txn, takeIt, now, conflictSet, lockedEntrySet,
+ provisionallyRemovedEntrySet);
+ } catch (CannotJoinException e) {
+ return false;
+ }
+ }
+
+ /* Now that we know we have a match, make sure that the the
+ * item in question is still in the space and hasn't been
+ * subject to other transactional-interference...
+ */
+ private boolean confirmAvailabilityWithTxn(EntryRep rep,
+ EntryHandle handle, TransactableMgr txnMgr, boolean takeIt,
+ long time, Set conflictSet, Set<Uuid> lockedEntrySet,
+ Set<EntryHandle> provisionallyRemovedEntrySet)
+ throws CannotJoinException
+ {
+ // Now that we know we have a match, make sure that the the
+ // item in question is still in the space and hasn't been
+ // subject to other transactional-interference...
+
+ // Lock the txn first (since that what everybody else does that)
+ // to ensure that the locking always happens in A cannonical
+ // order. We lock the transaction (txn) object to ensure that the
+ // transaction hasn't been altered behind our backs. Other, cheaper
+ // actions with the space (write, etc.) are handled nicely in
+ // OutriggerServerImpl. But, this one (reading/taking) was expensive
+ // enough that we wanted to do it here, where the window is
+ // smallest.
+ // Bug 4394263...
+
+ final Txn txn = (Txn)txnMgr;
+ try {
+ if (txn != null)
+ txn.ensureActive();
+
+ return confirmAvailability(rep, handle, txn,
+ takeIt, time, conflictSet, lockedEntrySet,
+ provisionallyRemovedEntrySet);
+ } finally {
+ if (txn != null)
+ txn.allowStateChange();
+ }
+ }
+
+ /**
+ * With the EntryRep <code>rep</code> passed in, verify that the
+ * entry hasn't been taken by someone else, hasn't expired, etc.
+ * Also, verify that the entry is really (legally) visible to this
+ * transaction at this time. If this is a <code>take</code>, it it
+ * is removed or provisionally removed. If this operation is under
+ * a transaction, the entry is locked appropriately.
+ */
+ // @see grab -- a helper routine
+ private boolean
+ confirmAvailability(EntryRep rep, EntryHandle handle,
+ TransactableMgr txn, boolean takeIt, long time,
+ Set conflictSet, Set<Uuid> lockedEntrySet,
+ Set<EntryHandle> provisionallyRemovedEntrySet)
+ {
+ synchronized (handle) {
+ if (handle.removed()) return false;
+ // get rid of stale entries
+ if (isExpired(time, handle))
+ return false;
+
+ if (handle.isProvisionallyRemoved()) {
+ if (provisionallyRemovedEntrySet != null)
+ provisionallyRemovedEntrySet.add(handle);
+ return false;
+ }
+
+ int op = (takeIt ? TransactableMgr.TAKE : TransactableMgr.READ);
+ if (!handle.canPerform(txn, op)) {
+ // Before deciding this is a conflict, we have to
+ // make sure we are not conflicting with ourselves.
+ if (handle.onlyMgr(txn))
+ // We are just conflicting with ourselves, this entry
+ // must have been taken by this txn already ... oh well
+ return false;
+
+ // Must be a real conflict, log if we were told too
+ if (matchingLogger.isLoggable(Level.FINER)) {
+ matchingLogger.log(Level.FINER, "match, but can''t " +
+ "perform {0}; handle.knownMgr(txn) == {1}",
+ new Object[] {Integer.valueOf(op),
+ Boolean.valueOf(handle.knownMgr(txn))});
+ }
+
+ if (conflictSet != null) {
+ handle.addTxns(conflictSet);
+ }
+
+ if (lockedEntrySet != null) {
+ lockedEntrySet.add(rep.id());
+ }
+
+ return false;
+ }
+
+ if (grab(handle, txn, op, takeIt, false))
+ return true;
+ else
+ throw
+ new AssertionError("entry became non-available while locked");
+ }
+ }
+
+ /**
+ * Given an entry that we want to return as the result of a query
+ * and we have confirmed we can return it, make the results of the
+ * query visible to the rest of the service. We must either [a]
+ * remove it from the holder (if the operation is a take under the
+ * same transaction the entry was written under), [b] mark it as
+ * provisionally removed pending commiting the operation to disk
+ * (if the operation is a take without a transaction), [c]
+ * lock it under the transaction passed into this method (if the
+ * operation is a read or take under a transaction), or [d] do
+ * nothing (read not under a transaction) as appropriate.
+ * <p>
+ * Also used during log recovery to recover takes.
+ *
+ * @param handle The handle attached to the particular EntryRep
+ * @param txn The Txn object
+ * @param op TAKE or READ (as a TransactableMgr constant)
+ * @param takeIt Is this a TAKE (or is it [false] a READ)
+ * @param recovery <code>true</code> if being called as
+ * part of store recovery.
+ * @return <code>true</code> if the entry could be grabbed.
+ * @throws NullPointerException if <code>handle</code> is
+ * <code>null</code>.
+ */
+ private boolean grab(EntryHandle handle, TransactableMgr txn, int op,
+ boolean takeIt, boolean recovery)
+ {
+ assert op==(takeIt?TransactableMgr.TAKE:TransactableMgr.READ);
+ assert !recovery || takeIt;
+
+ /*
+ * If this manager (txn) is known to the handle, then txn
+ * is a transaction which can operate directly on the
+ * existing handle. If so, then we can operate on it
+ * directly. Note that if txn is null and the handle is
+ * not managed, then txn is "known" in this sense.
+ *
+ * Else, this operation is new relative to the
+ * known transactions (possibly null) and txn.
+ */
+
+ if (handle.knownMgr(txn)) { // added or read in this txn if taking
+ // take it if we have to (otherwise it must be a read
+ // there is no house keeping to be done since must already
+ // be read locked)
+
+ if (takeIt) {
+ // is this an entry that was written under this
+ // transaction or another?
+
+ if (handle.managed()) {
+ // It is locked by a transaction and it must
+ // be the one this take is under.
+
+ if (!handle.promoteToTakeIfNeeded()) {
+ // this transaction wrote the entry (note txn
+ // must be non-null, otherwise either
+ // handle.managed or handle.knownMgr(txn)
+ // would have returned null), just need to try
+ // and remove it
+ assert txn != null;
+
+ // It is ok to call remove before committing this
+ // op to disk since a crash will cause the original
+ // write to be undone and the entry will still
+ // end up being removed.
+ if (!remove(handle, recovery))
+ // Someone got to it first
+ return false;
+ }
+
+ // Otherwise it was read locked (now take
+ // locked and needs to still be semi-visible
+ // to ifExists queries outside of the
+ // transaction, leave it in place with its new
+ // lock type (aka "state")
+
+ } else {
+ // Nether the entry nor this take are under a
+ // transaction (txn must be null because the
+ // that is the only way knownMgr return true, and
+ // managed() false)
+ assert txn == null;
+ synchronized (handle){
+ if (handle.removed() || handle.isProvisionallyRemoved())
+ // Someone got to it first
+ return false;
+ handle.provisionallyRemove();
+ }
+ }
+ }
+ } else {
+ if (txn != null) {
+ // We need to add this txn to this handle and
+ // add this handle to this txn.
+ handle.add(txn, op, this); // add manager to handle's list
+ txn.add(handle); // add handle to mgr's list
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Recover a logged take.
+ * @param handle The <code>EntryHandle</code> of the entry who's
+ * take is being logged.
+ * @param txn If non-null the transaction the take was performed
+ * under.
+ * @throws NullPointerException if <code>handle</code> is
+ * <code>null</code>.
+ */
+ void recoverTake(EntryHandle handle, Txn txn) {
+ if (!grab(handle, txn, TransactableMgr.TAKE, true, true))
+ throw
+ new AssertionError("match not found while recovering take");
+ }
+
+
+ /**
+ * Return <code>true</code> if the entry held by the given
+ * <code>handle</code> has expired by the time in <code>now</code>.
+ */
+ private boolean isExpired(long now, EntryHandle handle) {
+ /* Some callers already own the lock on handle when
+ * they call us, but the general feeling is that
+ * re-synchronizing is not costly and it is important
+ * to only call remove if we own the lock.
+ */
+ synchronized (handle) {
+ final EntryRep rep = handle.rep();
+ synchronized (rep) {
+ if (rep.getExpiration() > now) {
+ // Not expired
+ return false;
+ }
+
+ /* Expired, set expiration to before the beginning of
+ * time so renew() (which does not lock on the handle,
+ * but the rep...) can't renew the lease once we leave
+ * this block, even it already has a ref to the
+ * rep. Everyone else locks on the handle so
+ * and makes sure the handle has not been removed
+ * before doing anything important.
+ */
+ rep.setExpiration(Long.MIN_VALUE);
+ }
+
+ // If we are here the lease must have expired
+ if (matchingLogger.isLoggable(Level.FINER)) {
+ matchingLogger.log(Level.FINER, "expired {0} at {1} (now {2})",
+ new Object[] {rep.id(),
+ Long.valueOf(rep.getExpiration()),
+ Long.valueOf(now)});
+ }
+
+ if (!handle.isProvisionallyRemoved() && remove(handle, false)) {
+ /* If we got to do the remove, schedule
+ * logging of the removal, otherwise
+ * someone else already did it, or will do it
+ */
+ space.scheduleCancelOp(rep.id());
+ }
+
+ return true;
+ }
+ }
+
+ /**
+ * Get the head of the contents list
+ * @return The head of the contents list, if it exists.
+ * null if the list is empty.
+ */
+ private EntryHandle getContentsHead(){
+ return content.peek();
+ }
+
+ /**
+ * Add new new entry to the holder. Assumes the lock
+ * on the handle is held if there is a possibility
+ * of concurrent access.
+ * @param handle The <code>EntryHandle</code> for the
+ * entry being added.
+ * @param txn If the add is being done under a
+ * transaction the <code>TransactableMgr</code> for
+ * that transaction.
+ * @throws NullPointerException if <code>handle</code> is
+ * <code>null</code>.
+ */
+ void add(EntryHandle handle, TransactableMgr txn) {
+ final EntryRep rep = handle.rep();
+
+ /* Make sure info duplicated across all the handles in this
+ * holder is shared.
+ *
+ * We make the head call before calling txn.add because
+ * it seems like better hygiene to fix reps state before
+ * exposing it to others (even though shareWith will
+ * not change handle's state materially).
+ */
+ final EntryHandle head = getContentsHead();
+ if (head != null && head != handle) rep.shareWith(head.rep());
+ synchronized (handle){ //typically synchronized externally anyway.
+ if (txn != null) txn.add(handle);
+ content.add(handle);
+ EntryHandle existed = idMap.putIfAbsent(rep.getCookie(), handle);
+ if (existed != null) throw new IllegalStateException("An EntryHandle with that Cookie already exists in idMap");
+ }
+ }
+
+ /**
+ * Return an array of the class names of the super classes of the
+ * entries in this holder, or <code>null</code> if the holder is
+ * empty.
+ */
+ String[] supertypes() {
+ final EntryHandle head = getContentsHead();
+ if (head == null)
+ return null;
+ return head.rep().superclasses();
+ }
+
+ /**
+ * Return an enumerator over the contents of this space that are visible
+ * from the given mgr.
+ */
+ RepEnum contents(TransactableMgr mgr) {
+ return new SimpleRepEnum(mgr);
+ }
+
+ /**
+ * The class that implements <code>RepEnum</code> for this class.
+ */
+ private class SimpleRepEnum implements RepEnum {
+ private final Iterator<EntryHandle> contentsIterator;
+ private final TransactableMgr mgr;
+ private final long startTime;
+
+ SimpleRepEnum(TransactableMgr mgr) {
+ this.mgr = mgr;
+ startTime = System.currentTimeMillis();
+ contentsIterator = content.iterator();
+ }
+
+ // inherit doc comment from superclass
+ public EntryRep nextRep() {
+ iteratorLogger.entering("SimpleRepEnum", "nextRep");
+ while (contentsIterator.hasNext()) {
+ EntryHandle handle = contentsIterator.next();
+ iteratorLogger.log(Level.FINEST,
+ "advanced current handle to {0}", handle);
+ /*
+ * Skip over handles which are either removed or unable to
+ * perform a READ operation.
+ */
+ synchronized (handle){
+ if (handle.canPerform(mgr, TransactableMgr.READ)
+ && !isExpired(startTime, handle) && !handle.removed()) {
+ return handle.rep();
+ }
+ }
+
+ }
+
+ return null;
+ }
+ }
+
+
+ /**
+ * Return an object that can be used to perform a query that can
+ * return multiple matches and be restarted in another thread.
+ *
+ * @param tmpls An array of templates. Query will yield any
+ * entry that matches one or more of the templates.
+ * @param txn Transaction that should be used with the query.
+ * May be <code>null</code>. If
+ * non-<code>null</code> any entries yielded by the
+ * query will be locked under the transaction.
+ * @param takeThem If <code>true</code> any entries yielded by
+ * the query should be removed.
+ * @param now Estimate of current time used to weed out
+ * expired entries, ok if old
+ * @return a new ContinuingQuery object.
+ */
+ ContinuingQuery continuingQuery(EntryRep[] tmpls, TransactableMgr txn,
+ boolean takeThem, long now)
+ {
+ return new ContinuingQuery(tmpls, txn, takeThem, now);
+ }
+
+ /**
+ * Object that can be used to perform a query that can
+ * return multiple matches and be restarted in another thread.
+ * Assumes that is being invoked from only one thread
+ * at a time, but does handle synchronization between concurrent
+ * queries on the parent <code>EntryHolder</code>.
+ */
+ class ContinuingQuery {
+ /** Templates being used for the query */
+ final private EntryRep[] tmpls;
+
+ /** Transaction (if any) being used for the query */
+ final private TransactableMgr txn;
+
+ /**
+ * <code>true</code> if entries yielded by the query should
+ * removed.
+ */
+ final private boolean takeThem;
+
+ /** <code>EntryHandleTmplDesc</code> for the templates */
+ final private ThreadLocal<EntryHandleTmplDesc[]> descLocal;
+
+
+ /** Time used to weed out expired entries, ok if old */
+ volatile long now;
+
+ /**
+ * Current position in parent <code>EntryHolder</code>'s
+ * <code>contents</code>
+ */
+ private final Iterator<EntryHandle> contentsIterator;
+
+ /**
+ * Create a new <code>ContinuingQuery</code> object.
+ *
+ * @param tmpls An array of templates. Query will yield any
+ * entry that matches one or more of the templates.
+ * @param txn Transaction that should be used with the query.
+ * May be <code>null</code>. If
+ * non-<code>null</code> any entries yielded by the
+ * query will be locked under the transaction.
+ * @param takeThem If <code>true</code> any entries yielded by
+ * the query should be removed.
+ * @param now Estimate of current time used to weed out
+ * expired entries, ok if old
+ */
+ // * @return a new ContinuingQuery object. (?)
+ private ContinuingQuery(EntryRep[] tmpls, TransactableMgr txn,
+ boolean takeThem, long now)
+ {
+ this.tmpls = tmpls;
+ this.txn = txn;
+ this.takeThem = takeThem;
+ this.now = now;
+ contentsIterator = content.iterator();
+ descLocal = new ThreadLocal<EntryHandleTmplDesc[]>();
+ }
+
+ /**
+ * <code>EntryHolder</code> queries have thread local state
+ * that get clobbered if another query (on a different or same
+ * <code>EntryHolder</code>, including <code>hasMatch</code>
+ * calls) is started in the same thread. The state also needs
+ * to be restored if it the query is continued in another
+ * thread. The <code>restart</code> method must be called to
+ * restore the thread local state.
+ * @param now Estimate of current time used to weed out
+ * expired entries, ok if old
+ */
+ void restart(long now) {
+ if (!contentsIterator.hasNext()) return;
+ this.now = now;
+ }
+
+ /**
+ * Return the next matching entry. Returns <code>null</code>
+ * if there are no matches remaining. Call {@link #restart
+ * restart} first if query is being used in a different thread
+ * from the last <code>next</code> call and/or the current
+ * thread has done any form of <code>EntryHolder</code> query
+ * on any holder since the last next call.
+ *
+ * @param conflictSet If non-null the <code>TransactableMgr</code>
+ * objects of any transactions that prevent
+ * a entry from being retured will
+ * be added to <code>conflictSet</code>. May
+ * be <code>null</code> in which case
+ * conflicting transaction will not be recorded.
+ * This method assumes that any concurrent access
+ * is being arbitrated by the set or by the caller.
+ * @param lockedEntrySet If non-null the ID of any entries that
+ * can't be retured because of conflicting
+ * transaction will be added to
+ * <code>lockedEntrySet</code>. May be
+ * <code>null</code> in which case unavailable
+ * entries will not be recorded. This method
+ * assumes that any concurrent access is being
+ * arbitrated by the set or by the caller.
+ * @param provisionallyRemovedEntrySet If the entry can not be
+ * read/taken because it has been provisionally
+ * removed then its handle will be placed in the
+ * passed <code>WeakHashMap</code> as a key (with
+ * null as the value). May be <code>null</code> in
+ * which case provisionally removed entries will not
+ * be recorded. This method assumes that any
+ * concurrent access is being arbitrated by the set
+ * or by the caller.
+ * @return a matching entry or <code>null</code>.
+ * @throws CannotJoinException if a match is found and
+ * the operation is to be performed under a transaction,
+ * but the transaction is no longer active.
+ */
+ EntryHandle next(Set conflictSet, Set<Uuid> lockedEntrySet, Set<EntryHandle> provisionallyRemovedEntrySet)
+ throws CannotJoinException
+ {
+ matchingLogger.entering("ContinuingQuery", "next");
+ EntryHandleTmplDesc[] descs = descLocal.get();
+ while (contentsIterator.hasNext()) {
+ EntryHandle handle = contentsIterator.next();
+ if(descs == null){
+ // first time
+ descs = new EntryHandleTmplDesc[tmpls.length];
+ for (int i=0; i<tmpls.length; i++) {
+ descs[i] = EntryHandle.descFor(tmpls[i],
+ handle.rep().numFields());
+ }
+ descLocal.set(descs);
+ }
+ if (handleMatch(handle, descs)) {
+ final boolean available =
+ confirmAvailabilityWithTxn(handle.rep(), handle, txn,
+ takeThem, now, conflictSet, lockedEntrySet,
+ provisionallyRemovedEntrySet);
+
+ if (available) return handle;
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Returns <code>true</code> if handle has not been removed
+ * and matches one or more of the templates
+ */
+ private boolean handleMatch(EntryHandle handle, EntryHandleTmplDesc[] descs) {
+ if (handle.removed()) return false;
+ int length = tmpls.length;
+ for (int i=0; i<length; i++) {
+ final EntryRep tmpl = tmpls[i];
+ final EntryHandleTmplDesc desc = descs[i];
+
+ // Quick reject
+ if ((handle.hash() & desc.mask) != desc.hash)
+ continue;
+ if (!tmpl.matches(handle.rep()))
+ continue;
+ return true;
+ }
+
+ return false;
+ }
+ }
+
+ /**
+ * Remove the given handle from this holder and the <code>idMap</code>.
+ * If the handle isn't in this holder, this does nothing.
+ * @param h the <code>EntryHandle</code> to remove.
+ * @param recovery <code>true</code> if being called as part
+ * of log recovery.
+ * @return <code>true</code> if this call removed <code>h</code> and
+ * <code>false</code> otherwise.
+ */
+ boolean remove(EntryHandle h, boolean recovery) {
+ boolean ok = false;
+ synchronized (h){
+ ok = h.remove();
+ if (!ok) throw new AssertionError("EntryHandle not removed");
+ h.removalComplete();
+ // Ensure removal of EntryHandle is atomic.
+ boolean removed = idMap.remove(h.rep().getCookie(), h);
+ if (!removed) throw new IllegalStateException ("EntryHandle was missing from idMap at time of removal");
+ /* This may cause an ifExists query to be resolved,
+ * even if this entry was not locked under a transaction
+ */
+ if (!recovery) {
+ space.recordTransition(
+ new EntryTransition(h, null, false, false, false));
+ }
+ }
+ return ok;
+ }
+
+ /**
+ * Reap the expired elements.
+ */
+ void reap() {
+
+ // Examine each of the elements to determine if
+ // any of them have expired. If they have, ensure that they are
+ // removed ("reaped") from the collection.
+
+ long now = System.currentTimeMillis();
+ for(EntryHandle handle : content){
+ // Don't try to remove things twice
+ if (handle.removed()) continue;
+ // Calling isExpired() will both make the check and remove it
+ // if necessary.
+ isExpired(now, handle);
+ }
+ }
+}
+
Modified: river/jtsk/modules/modularize/apache-river/river-services/outrigger/outrigger-service/src/main/java/org/apache/river/outrigger/EntryHolderSet.java
URL: http://svn.apache.org/viewvc/river/jtsk/modules/modularize/apache-river/river-services/outrigger/outrigger-service/src/main/java/org/apache/river/outrigger/EntryHolderSet.java?rev=1879521&r1=1879520&r2=1879521&view=diff
==============================================================================
--- river/jtsk/modules/modularize/apache-river/river-services/outrigger/outrigger-service/src/main/java/org/apache/river/outrigger/EntryHolderSet.java (original)
+++ river/jtsk/modules/modularize/apache-river/river-services/outrigger/outrigger-service/src/main/java/org/apache/river/outrigger/EntryHolderSet.java Sun Jul 5 11:41:39 2020
@@ -1,130 +1,133 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you 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.
- */
-package org.apache.river.outrigger;
-
-import java.util.Hashtable;
-import java.util.Map;
-import java.util.Collection;
-
-import net.jini.core.lease.Lease;
-import net.jini.id.Uuid;
-import org.apache.river.landlord.LeasedResource;
-import java.util.Iterator;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-
-/**
- * A set of <code>EntryHolder</code> objects for a given space.
- *
- * @author Sun Microsystems, Inc.
- *
- * @see EntryHolder
- * @see OutriggerServerImpl
- */
-final class EntryHolderSet {
- private final ConcurrentMap<String,EntryHolder> holders = new ConcurrentHashMap<String,EntryHolder>();
- // Map of LeaseDescs indexed by the cookie of the underlying
- // LeasedResource.
- private final ConcurrentMap<Uuid, EntryHandle> idMap = new ConcurrentHashMap<Uuid, EntryHandle>();
-
- private final OutriggerServerImpl space;
-
- EntryHolderSet(OutriggerServerImpl space) {
- this.space = space;
- }
-
- /**
- * Return the <code>EntryHolder</code> object for the exact class
- * of the <code>Entry</code> object held in <code>bits</code>. If
- * one doesn't yet exist, it will be created.
- *
- * @see #holderFor(java.lang.String)
- */
- EntryHolder holderFor(EntryRep rep) {
- return holderFor(rep.classFor());
- }
-
- /**
- * Return the <code>EntryHolder</code> object for the exact class
- * with the given ID. If one doesn't yet exist, it will be created.
- *
- * @see #holderFor(EntryRep)
- */
- EntryHolder holderFor(String className) {
- EntryHolder holder = holders.get(className);
- if (holder == null) {
- holder = new EntryHolder(space, idMap);
- EntryHolder exists = holders.putIfAbsent(className, holder);
- if (exists != null) holder = exists;
- }
- return holder;
- }
-
- LeasedResource getLeasedResource(Uuid cookie) {
- final EntryHandle handle = handleFor(cookie);
- if (handle == null)
- return null;
- return handle.getLeasedResource();
- }
-
- /**
- * Given an entry ID, return the handle associated
- * with it.
- */
- EntryHandle handleFor(Object cookie) {
- return idMap.get(cookie);
- }
-
- /**
- * Remove the passed handle and associated entry.
- * Assumes the caller holds the lock on handle
- */
- void remove(EntryHandle handle) {
- final EntryHolder holder = holders.get(handle.rep().classFor());
- if (holder == null) return;
- holder.remove(handle, false);
- }
-
- /**
- * Force all of the holders to reap their <code>FastList</code>s
- */
- void reap() {
- /* This could take a while, instead of blocking all other
- * access to holders, clone the contents of holders and
- * iterate down the clone (we don't do this too often and
- * holders should never be that big so a shallow copy should
- * not be that bad, if it did get to be bad caching the
- * clone would probably work well since we don't add (and
- * never remove) elements that often.)
- */
-// final EntryHolder content[];
-// synchronized (holders) {
-// final Collection values = holders.values();
-// content = new EntryHolder[values.size()];
-// values.toArray(content);
-// }
-//
-// for (int i=0; i<content.length; i++) {
-// content[i].reap();
-// }
- Iterator<EntryHolder> it = holders.values().iterator();
- while (it.hasNext()){
- it.next().reap();
- }
- }
-}
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ */
+package org.apache.river.outrigger;
+
+import java.util.Hashtable;
+import java.util.Map;
+import java.util.Collection;
+
+import net.jini.core.lease.Lease;
+import net.jini.id.Uuid;
+import org.apache.river.landlord.LeasedResource;
+import java.util.Iterator;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+import org.apache.river.outrigger.proxy.EntryRep;
+
+
+/**
+ * A set of <code>EntryHolder</code> objects for a given space.
+ *
+ * @author Sun Microsystems, Inc.
+ *
+ * @see EntryHolder
+ * @see OutriggerServerImpl
+ */
+final class EntryHolderSet {
+ private final ConcurrentMap<String,EntryHolder> holders = new ConcurrentHashMap<String,EntryHolder>();
+ // Map of LeaseDescs indexed by the cookie of the underlying
+ // LeasedResource.
+ private final ConcurrentMap<Uuid, EntryHandle> idMap = new ConcurrentHashMap<Uuid, EntryHandle>();
+
+ private final OutriggerServerImpl space;
+
+ EntryHolderSet(OutriggerServerImpl space) {
+ this.space = space;
+ }
+
+ /**
+ * Return the <code>EntryHolder</code> object for the exact class
+ * of the <code>Entry</code> object held in <code>bits</code>. If
+ * one doesn't yet exist, it will be created.
+ *
+ * @see #holderFor(java.lang.String)
+ */
+ EntryHolder holderFor(EntryRep rep) {
+ return holderFor(rep.classFor());
+ }
+
+ /**
+ * Return the <code>EntryHolder</code> object for the exact class
+ * with the given ID. If one doesn't yet exist, it will be created.
+ *
+ * @see #holderFor(EntryRep)
+ */
+ EntryHolder holderFor(String className) {
+ EntryHolder holder = holders.get(className);
+ if (holder == null) {
+ holder = new EntryHolder(space, idMap);
+ EntryHolder exists = holders.putIfAbsent(className, holder);
+ if (exists != null) holder = exists;
+ }
+ return holder;
+ }
+
+ LeasedResource getLeasedResource(Uuid cookie) {
+ final EntryHandle handle = handleFor(cookie);
+ if (handle == null)
+ return null;
+ return handle.getLeasedResource();
+ }
+
+ /**
+ * Given an entry ID, return the handle associated
+ * with it.
+ */
+ EntryHandle handleFor(Object cookie) {
+ return idMap.get(cookie);
+ }
+
+ /**
+ * Remove the passed handle and associated entry.
+ * Assumes the caller holds the lock on handle
+ */
+ void remove(EntryHandle handle) {
+ final EntryHolder holder = holders.get(handle.rep().classFor());
+ if (holder == null) return;
+ holder.remove(handle, false);
+ }
+
+ /**
+ * Force all of the holders to reap their <code>FastList</code>s
+ */
+ void reap() {
+ /* This could take a while, instead of blocking all other
+ * access to holders, clone the contents of holders and
+ * iterate down the clone (we don't do this too often and
+ * holders should never be that big so a shallow copy should
+ * not be that bad, if it did get to be bad caching the
+ * clone would probably work well since we don't add (and
+ * never remove) elements that often.)
+ */
+// final EntryHolder content[];
+// synchronized (holders) {
+// final Collection values = holders.values();
+// content = new EntryHolder[values.size()];
+// values.toArray(content);
+// }
+//
+// for (int i=0; i<content.length; i++) {
+// content[i].reap();
+// }
+ Iterator<EntryHolder> it = holders.values().iterator();
+ while (it.hasNext()){
+ it.next().reap();
+ }
+ }
+}