bitronix.tm.resource.common.ResourceBean Maven / Gradle / Ivy
/*
* Copyright (C) 2006-2013 Bitronix Software (http://www.bitronix.be)
*
* 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 bitronix.tm.resource.common;
import java.io.Serializable;
import java.util.Properties;
/**
* Abstract javabean container for all common properties of a {@link bitronix.tm.resource.common.XAResourceProducer} as configured in the
* resources configuration file.
*
* @author Ludovic Orban
*/
@SuppressWarnings("serial")
public abstract class ResourceBean
implements Serializable
{
private volatile String className;
private volatile String uniqueName;
private volatile boolean automaticEnlistingEnabled = true;
private volatile boolean useTmJoin = true;
private volatile Properties driverProperties = new Properties();
private volatile int maxPoolSize = 0;
private volatile int minPoolSize = 0;
private volatile int maxIdleTime = 60;
private volatile int maxLifeTime = 0;
private volatile int acquireIncrement = 1;
private volatile int acquisitionTimeout = 30;
private volatile boolean deferConnectionRelease = true;
private volatile int acquisitionInterval = 1;
private volatile boolean allowLocalTransactions = false;
private volatile int twoPcOrderingPosition = 1;
private volatile boolean applyTransactionTimeout = false;
private volatile boolean shareTransactionConnections = false;
private volatile boolean disabled = false;
private volatile boolean ignoreRecoveryFailures = false;
private transient volatile int createdResourcesCounter;
/**
* Initialize all properties with their default values.
*/
protected ResourceBean()
{
}
/**
* @return the underlying implementation class name.
*/
public String getClassName()
{
return className;
}
/**
* Specify the underlying implementation class name of the XA resource described by this bean.
*
* @param className
* the underlying implementation class name.
*/
public void setClassName(String className)
{
this.className = className;
}
/**
* @return the resource's unique name.
*/
public String getUniqueName()
{
return uniqueName;
}
/**
* Specify the resource unique name to be used to identify this resource during recovery. This name will be
* registered in the transactions journal so once assigned it must never be changed.
*
* @param uniqueName
* the resource's unique name.
*/
public void setUniqueName(String uniqueName)
{
this.uniqueName = uniqueName;
}
/**
* @return true if the the XA resource wrapper should enlist/delist this resource automatically in global
* transactions.
*/
public boolean getAutomaticEnlistingEnabled()
{
return automaticEnlistingEnabled;
}
/**
* Specify if the XA resource wrapper should enlist/delist this resource automatically in global transactions.
* When set to false, you have to enlist resources yourself with {@link jakarta.transaction.Transaction#enlistResource(javax.transaction.xa.XAResource)} and delist them
* {@link jakarta.transaction.Transaction#delistResource(javax.transaction.xa.XAResource, int)}.
*
* @param automaticEnlistingEnabled
* true if the the XA resource wrapper should enlist/delist this resource automatically in global
* transactions.
*/
public void setAutomaticEnlistingEnabled(boolean automaticEnlistingEnabled)
{
this.automaticEnlistingEnabled = automaticEnlistingEnabled;
}
/**
* @return true if transaction branches joining should be used.
*/
public boolean getUseTmJoin()
{
return useTmJoin;
}
/**
* Specify if the transaction manager should try to join resources by calling
* {@link javax.transaction.xa.XAResource#start(javax.transaction.xa.Xid, int)} with
* {@link javax.transaction.xa.XAResource#TMJOIN}. The transaction manager checks if two branches can be joined by
* calling {@link javax.transaction.xa.XAResource#isSameRM(javax.transaction.xa.XAResource)}.
* It should only be set to true if the underlying implementation supports resource joining.
*
* @param useTmJoin
* true if transaction branches joining should be used.
*/
public void setUseTmJoin(boolean useTmJoin)
{
this.useTmJoin = useTmJoin;
}
/**
* @return the properties that should be set on the underlying implementation.
*/
public Properties getDriverProperties()
{
return driverProperties;
}
/**
* Set the properties that should be set on the underlying implementation.
*
* @param driverProperties
* the properties that should be set on the underlying implementation.
*/
public void setDriverProperties(Properties driverProperties)
{
this.driverProperties = driverProperties;
}
/**
* @return the maximum amount of connections that can be in the pool.
*/
public int getMaxPoolSize()
{
return maxPoolSize;
}
/**
* Define the maximum amount of connections that can be in the pool.
*
* @param maxPoolSize
* the maximum amount of connections that can be in the pool.
*/
public void setMaxPoolSize(int maxPoolSize)
{
this.maxPoolSize = maxPoolSize;
}
/**
* @return the minimal amount of connections that can be in the pool.
*/
public int getMinPoolSize()
{
return minPoolSize;
}
/**
* Define the minimal amount of connections that can be in the pool.
*
* @param minPoolSize
* the maximum amount of connections that can be in the pool.
*/
public void setMinPoolSize(int minPoolSize)
{
this.minPoolSize = minPoolSize;
}
/**
* @return the amount of seconds and idle connection can stay in the pool before getting closed.
*/
public int getMaxIdleTime()
{
return maxIdleTime;
}
/**
* Define the amount of seconds and idle connection can stay in the pool before getting closed.
*
* @param maxIdleTime
* the amount of seconds and idle connection can stay in the pool before getting closed.
*/
public void setMaxIdleTime(int maxIdleTime)
{
this.maxIdleTime = maxIdleTime;
}
/**
* @return the maximum lifetime (in seconds) that a connection can stay in the pool before getting closed.
*/
public int getMaxLifeTime()
{
return maxLifeTime;
}
/**
* Define the maximum lifetime (in seconds) that a connection can stay in the pool before getting closed.
*
* @param maxLifeTime
* the maximum lifetime (in seconds) that a connection can stay in the pool before getting closed.
*/
public void setMaxLifeTime(int maxLifeTime)
{
this.maxLifeTime = maxLifeTime;
}
/**
* @return the amount of connections to be created at once when the pool needs to grow.
*/
public int getAcquireIncrement()
{
return acquireIncrement;
}
/**
* Define the amount of connections to be created at once when the pool needs to grow.
*
* @param acquireIncrement
* the amount of connections to be created at once when the pool needs to grow.
*/
public void setAcquireIncrement(int acquireIncrement)
{
this.acquireIncrement = acquireIncrement;
}
/**
* @return the amount of time in seconds a call to get a connection from the pool will wait when the pool is empty.
*/
public int getAcquisitionTimeout()
{
return acquisitionTimeout;
}
/**
* Define the amount of time in seconds a call to get a connection from the pool will wait when the pool is empty.
*
* @param acquisitionTimeout
* the amount of time in seconds.
*/
public void setAcquisitionTimeout(int acquisitionTimeout)
{
this.acquisitionTimeout = acquisitionTimeout;
}
/**
* @return false only if the database can run many transactions on the same connection.
*/
public boolean getDeferConnectionRelease()
{
return deferConnectionRelease;
}
/**
* Define the transaction interleaving capability of the database.
* Should be true only if the database can run many transactions on the same connection.
*
* @param deferConnectionRelease
* false only if the database can run many transactions on the same connection.
*/
public void setDeferConnectionRelease(boolean deferConnectionRelease)
{
this.deferConnectionRelease = deferConnectionRelease;
}
/**
* @return the amount of time between failed connection acquirements.
*/
public int getAcquisitionInterval()
{
return acquisitionInterval;
}
/**
* Set the amount of time in seconds the pool will wait before trying to acquire a connection again after an
* invalid connection has been attempted to be acquired.
*
* @param acquisitionInterval
* amount of time in seconds.
*/
public void setAcquisitionInterval(int acquisitionInterval)
{
this.acquisitionInterval = acquisitionInterval;
}
/**
* @return true if the transaction manager should allow mixing XA and non-XA transactions.
*/
public boolean getAllowLocalTransactions()
{
return allowLocalTransactions;
}
/**
* Set if the transaction manager should allow mixing XA and non-XA transactions. If you know all your transactions
* should be executed within global (ie: XA) scope it is a good idea to set this property to false.
*
* @param allowLocalTransactions
* if the transaction manager should allow mixing XA and non-XA transactions.
*/
public void setAllowLocalTransactions(boolean allowLocalTransactions)
{
this.allowLocalTransactions = allowLocalTransactions;
}
/**
* @return the position at which this resource should stand during 2PC commit.
*/
public int getTwoPcOrderingPosition()
{
return twoPcOrderingPosition;
}
/**
* Set the position at which this resource should stand during 2PC commit.
*
* @param twoPcOrderingPosition
* the position at which this resource should stand during 2PC commit.
*/
public void setTwoPcOrderingPosition(int twoPcOrderingPosition)
{
this.twoPcOrderingPosition = twoPcOrderingPosition;
}
/**
* @return true if the transaction-timeout should be set on the XAResource.
*/
public boolean getApplyTransactionTimeout()
{
return applyTransactionTimeout;
}
/**
* Set if the transaction-timeout should be set on the XAResource when the XAResource is
* enlisted.
*
* @param applyTransactionTimeout
* true if the transaction-timeout should be set.
*/
public void setApplyTransactionTimeout(boolean applyTransactionTimeout)
{
this.applyTransactionTimeout = applyTransactionTimeout;
}
/**
* @return true if accessible connections can be shared.
*/
public boolean getShareTransactionConnections()
{
return shareTransactionConnections;
}
/**
* Set whether connections in the ACCESSIBLE state can be shared within the context
* of a transaction.
*
* @param shareAccessibleConnections
* the shareAccessibleConnections to set.
*/
public void setShareTransactionConnections(boolean shareAccessibleConnections)
{
this.shareTransactionConnections = shareAccessibleConnections;
}
/**
* @return true if recovery errors should be ignored, false otherwise.
*/
public boolean getIgnoreRecoveryFailures()
{
return ignoreRecoveryFailures;
}
/**
* Set whether XA recovery errors should quarantine the resource or be ignored.
*
* @param ignoreRecoveryFailures
* true if recovery errors should be ignored, false otherwise.
*/
public void setIgnoreRecoveryFailures(boolean ignoreRecoveryFailures)
{
this.ignoreRecoveryFailures = ignoreRecoveryFailures;
}
/**
* @return true if the resource is disabled, false if it is enabled.
*/
public boolean isDisabled()
{
return disabled;
}
/**
* Set whether this resource is disabled, meaning it's temporarily forbidden to acquire
* a connection from its pool.
*
* @param disabled
* true to disable the resource, false to enable it.
*/
public void setDisabled(boolean disabled)
{
this.disabled = disabled;
}
/**
* Increment a transient counter. This is used for assigning per-resource numbers to connections.
*
* @return the current value of the counter.
*/
public int incCreatedResourcesCounter()
{
return this.createdResourcesCounter++;
}
}