io.logspace.agent.shaded.quartz.impl.jdbcjobstore.JTANonClusteredSemaphore Maven / Gradle / Ivy
/*
* Copyright 2001-2009 Terracotta, Inc.
*
* 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.
*
*/
package io.logspace.agent.shaded.quartz.impl.jdbcjobstore;
import java.sql.Connection;
import java.util.HashSet;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.transaction.Synchronization;
import javax.transaction.SystemException;
import javax.transaction.Transaction;
import javax.transaction.TransactionManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Provides in memory thread/resource locking that is JTA
* {@link javax.transaction.Transaction} aware.
* It is most appropriate for use when using
* {@link io.logspace.agent.shaded.quartz.impl.jdbcjobstore.JobStoreCMT} without clustering.
*
*
* This Semaphore implementation is not Quartz cluster safe.
*
*
*
* When a lock is obtained/released but there is no active JTA
* {@link javax.transaction.Transaction}, then this Semaphore operates
* just like {@link io.logspace.agent.shaded.quartz.impl.jdbcjobstore.SimpleSemaphore}.
*
*
*
* By default, this class looks for the {@link javax.transaction.TransactionManager}
* in JNDI under name "java:TransactionManager". If this is not where your Application Server
* registers it, you can modify the JNDI lookup location using the
* "transactionManagerJNDIName" property.
*
*
*
* IMPORTANT: This Semaphore implementation is currently experimental.
* It has been tested a limited amount on JBoss 4.0.3SP1. If you do choose to
* use it, any feedback would be most appreciated!
*
*
* @see io.logspace.agent.shaded.quartz.impl.jdbcjobstore.SimpleSemaphore
*/
public class JTANonClusteredSemaphore implements Semaphore {
/*
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*
* Data members.
*
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
public static final String DEFAULT_TRANSACTION_MANANGER_LOCATION = "java:TransactionManager";
ThreadLocal> lockOwners = new ThreadLocal>();
HashSet locks = new HashSet();
private final Logger log = LoggerFactory.getLogger(getClass());
private String transactionManagerJNDIName = DEFAULT_TRANSACTION_MANANGER_LOCATION;
/*
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*
* Interface.
*
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
protected Logger getLog() {
return log;
}
public void setTransactionManagerJNDIName(String transactionManagerJNDIName) {
this.transactionManagerJNDIName = transactionManagerJNDIName;
}
private HashSet getThreadLocks() {
HashSet threadLocks = lockOwners.get();
if (threadLocks == null) {
threadLocks = new HashSet();
lockOwners.set(threadLocks);
}
return threadLocks;
}
/**
* Grants a lock on the identified resource to the calling thread (blocking
* until it is available).
*
* @return true if the lock was obtained.
*/
public synchronized boolean obtainLock(Connection conn, String lockName) throws LockException {
lockName = lockName.intern();
if(log.isDebugEnabled()) {
log.debug(
"Lock '" + lockName + "' is desired by: "
+ Thread.currentThread().getName());
}
if (!isLockOwner(conn, lockName)) {
if(log.isDebugEnabled()) {
log.debug(
"Lock '" + lockName + "' is being obtained: "
+ Thread.currentThread().getName());
}
while (locks.contains(lockName)) {
try {
this.wait();
} catch (InterruptedException ie) {
if(log.isDebugEnabled()) {
log.debug(
"Lock '" + lockName + "' was not obtained by: "
+ Thread.currentThread().getName());
}
}
}
// If we are in a transaction, register a callback to actually release
// the lock when the transaction completes
Transaction t = getTransaction();
if (t != null) {
try {
t.registerSynchronization(new SemaphoreSynchronization(lockName));
} catch (Exception e) {
throw new LockException("Failed to register semaphore with Transaction.", e);
}
}
if(log.isDebugEnabled()) {
log.debug(
"Lock '" + lockName + "' given to: "
+ Thread.currentThread().getName());
}
getThreadLocks().add(lockName);
locks.add(lockName);
} else if(log.isDebugEnabled()) {
log.debug(
"Lock '" + lockName + "' already owned by: "
+ Thread.currentThread().getName()
+ " -- but not owner!",
new Exception("stack-trace of wrongful returner"));
}
return true;
}
/**
* Helper method to get the current {@link javax.transaction.Transaction}
* from the {@link javax.transaction.TransactionManager} in JNDI.
*
* @return The current {@link javax.transaction.Transaction}, null if
* not currently in a transaction.
*/
protected Transaction getTransaction() throws LockException{
InitialContext ic = null;
try {
ic = new InitialContext();
TransactionManager tm = (TransactionManager)ic.lookup(transactionManagerJNDIName);
return tm.getTransaction();
} catch (SystemException e) {
throw new LockException("Failed to get Transaction from TransactionManager", e);
} catch (NamingException e) {
throw new LockException("Failed to find TransactionManager in JNDI under name: " + transactionManagerJNDIName, e);
} finally {
if (ic != null) {
try {
ic.close();
} catch (NamingException ignored) {
}
}
}
}
/**
* Release the lock on the identified resource if it is held by the calling
* thread, unless currently in a JTA transaction.
*/
public synchronized void releaseLock(String lockName) throws LockException {
releaseLock(lockName, false);
}
/**
* Release the lock on the identified resource if it is held by the calling
* thread, unless currently in a JTA transaction.
*
* @param fromSynchronization True if this method is being invoked from
* {@link Synchronization} notified of the enclosing
* transaction having completed.
*
* @throws LockException Thrown if there was a problem accessing the JTA
* Transaction. Only relevant if fromSynchronization
* is false.
*/
protected synchronized void releaseLock(
String lockName, boolean fromSynchronization) throws LockException {
lockName = lockName.intern();
if (isLockOwner(null, lockName)) {
if (fromSynchronization == false) {
Transaction t = getTransaction();
if (t != null) {
if(getLog().isDebugEnabled()) {
getLog().debug(
"Lock '" + lockName + "' is in a JTA transaction. " +
"Return deferred by: " + Thread.currentThread().getName());
}
// If we are still in a transaction, then we don't want to
// actually release the lock.
return;
}
}
if(getLog().isDebugEnabled()) {
getLog().debug(
"Lock '" + lockName + "' returned by: "
+ Thread.currentThread().getName());
}
getThreadLocks().remove(lockName);
locks.remove(lockName);
this.notify();
} else if (getLog().isDebugEnabled()) {
getLog().debug(
"Lock '" + lockName + "' attempt to return by: "
+ Thread.currentThread().getName()
+ " -- but not owner!",
new Exception("stack-trace of wrongful returner"));
}
}
/**
* Determine whether the calling thread owns a lock on the identified
* resource.
*/
public synchronized boolean isLockOwner(Connection conn, String lockName) {
lockName = lockName.intern();
return getThreadLocks().contains(lockName);
}
/**
* This Semaphore implementation does not use the database.
*/
public boolean requiresConnection() {
return false;
}
/**
* Helper class that is registered with the active
* {@link javax.transaction.Transaction} so that the lock
* will be released when the transaction completes.
*/
private class SemaphoreSynchronization implements Synchronization {
private String lockName;
public SemaphoreSynchronization(String lockName) {
this.lockName = lockName;
}
public void beforeCompletion() {
// nothing to do...
}
public void afterCompletion(int status) {
try {
releaseLock(lockName, true);
} catch (LockException e) {
// Ignore as can't be thrown with fromSynchronization set to true
}
}
}
}