Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 1997-2013 Oracle and/or its affiliates. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can
* obtain a copy of the License at
* https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
* or packager/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at packager/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* Oracle designates this particular file as subject to the "Classpath"
* exception as provided by Oracle in the GPL Version 2 section of the License
* file that accompanied this code.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [year] [name of copyright owner]"
*
* Contributor(s):
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
// Portions Copyright [2016-2021] [Payara Foundation and/or its affiliates]
package com.sun.enterprise.transaction;
import com.sun.enterprise.transaction.api.JavaEETransaction;
import com.sun.enterprise.transaction.api.JavaEETransactionManager;
import com.sun.enterprise.transaction.api.SimpleResource;
import com.sun.enterprise.transaction.spi.TransactionInternal;
import com.sun.enterprise.transaction.spi.TransactionalResource;
import com.sun.enterprise.util.Utility;
import com.sun.enterprise.util.i18n.StringManager;
import com.sun.logging.LogDomains;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.atomic.AtomicLong;
import java.util.logging.Level;
import java.util.logging.Logger;
import jakarta.persistence.EntityManagerFactory;
import jakarta.transaction.HeuristicMixedException;
import jakarta.transaction.HeuristicRollbackException;
import jakarta.transaction.RollbackException;
import jakarta.transaction.Status;
import jakarta.transaction.Synchronization;
import jakarta.transaction.SystemException;
import javax.transaction.xa.XAResource;
import javax.transaction.xa.Xid;
/**
* This class implements the JTA Transaction API for the J2EE RI.
* It is a wrapper over the JTS Transaction object that provides optimized local
* transaction support when a transaction uses zero/one non-XA resource,
* and delegates to JTS otherwise.
* This object can be in two states: local tx (jtsTx==null) or global (JTS) tx.
* If jtsTx!=null, all calls are delegated to jtsTx.
*
* Time out capability is added to the local transactions. This class extends the TimerTask.
* When the transaction needs to be timedout, this schedules with the timer. At the commit
* and rollback time, task will be cancelled. If the transaction is timedout, run() method
* will be called and transaction will be marked for rollback.
*/
public final class JavaEETransactionImpl implements Runnable, JavaEETransaction {
private static final Logger _logger = LogDomains.getLogger(JavaEETransactionImpl.class, LogDomains.JTA_LOGGER);
// Sting Manager for Localization
private static final StringManager sm = StringManager.getManager(JavaEETransactionImpl.class);
// Local Tx ids are just numbers: they dont need to be unique across
// processes or across multiple activations of this server process.
private static final AtomicLong TX_ID_COUNTER = new AtomicLong(1L);
// Fall back to the old (wrong) behavior for the case when setRollbackOnly
// was called before XA transaction started
private static final boolean DISABLE_STATUS_CHECK_ON_SWITCH_TO_XA = //
Boolean.getBoolean("com.sun.jts.disable_status_check_on_switch_to_xa");
private final JavaEETransactionManager javaEETM;
private final long txId;
private final JavaEEXid xid;
private TransactionInternal jtsTx;
private TransactionalResource nonXAResource;
private TransactionalResource laoResource;
private int localTxStatus;
private final Vector syncs = new Vector();
private final Vector interposedSyncs = new Vector();
private boolean commitStarted = false;
// START 4662745
private final long startTime;
// END 4662745
// START: local transaction timeout
private boolean timedOut = false;
private boolean isTimerTask = false;
private int timeout = 0;
// END: local transaction timeout
private boolean imported = false;
private final Map resourceTable;
private Map userResourceMap;
//This cache contains the EntityContexts in this Tx
private Object activeTxCache;
// SimpleResource mapping for EMs with TX persistent context type
private Map txEntityManagerMap;
// SimpleResource mapping for EMs with EXTENDED persistence context type
private Map extendedEntityManagerMap;
private String componentName = null;
private List resourceNames = null;
// tx-specific ejb container info associated with this tx
private Object containerData = null;
private ScheduledFuture scheduledTimeoutFuture;
JavaEETransactionImpl(JavaEETransactionManager javaEETM) {
this.javaEETM = javaEETM;
this.txId = getNewTxId();
this.xid = new JavaEEXid(txId);
this.resourceTable = new HashMap<>();
localTxStatus = Status.STATUS_ACTIVE;
startTime=System.currentTimeMillis();
if (_logger != null && _logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE, "--Created new JavaEETransactionImpl, txId = " + txId);
}
}
// START: local transaction timeout
JavaEETransactionImpl(int timeout, JavaEETransactionManager javaEETM) {
this(javaEETM);
isTimerTask = true;
this.timeout = timeout;
}
// END: local transaction timeout
JavaEETransactionImpl(TransactionInternal jtsTx, JavaEETransactionManager javaEETM) {
this(javaEETM);
this.jtsTx = jtsTx;
imported = true;
}
void setScheduledTimeoutFuture(ScheduledFuture scheduledTimeoutFuture) {
this.scheduledTimeoutFuture = scheduledTimeoutFuture;
}
// START: local transaction timeout
// TimerTask run() method implementation
@Override
public void run() {
timedOut = true;
final long time = System.currentTimeMillis() - startTime;
_logger.warning(() -> String.format("Transaction with id=%s timed out after %s ms.", txId, time));
try {
setRollbackOnly();
} catch (Exception e) {
_logger.log(Level.WARNING, "enterprise_distributedtx.some_excep", e);
}
}
@Override
public Object getContainerData() {
return containerData;
}
@Override
public void setContainerData(Object data) {
containerData = data;
}
boolean isAssociatedTimeout() {
return isTimerTask;
}
// Cancels the timertask and returns the timeout
public int cancelTimerTask() {
cancel();
return timeout;
}
private void cancel() {
if (scheduledTimeoutFuture != null) {
if(!scheduledTimeoutFuture.isCancelled() && !scheduledTimeoutFuture.isDone()) {
scheduledTimeoutFuture.cancel(false);
}
scheduledTimeoutFuture = null;
}
}
@Override
public boolean isTimedOut() {
return timedOut;
}
// END: local transaction timeout
private static long getNewTxId() {
return TX_ID_COUNTER.getAndIncrement();
}
@Override
public boolean equals(Object other) {
if ( other == this ) {
return true;
}
if ( other instanceof JavaEETransactionImpl ) {
JavaEETransactionImpl othertx = (JavaEETransactionImpl)other;
return ( txId == othertx.txId );
}
return false;
}
@Override
public int hashCode() {
return (int)txId;
}
Xid getLocalXid() {
return xid;
}
@Override
public TransactionalResource getNonXAResource() {
return nonXAResource;
}
void setNonXAResource(TransactionalResource h) {
nonXAResource = h;
}
@Override
public TransactionalResource getLAOResource() {
return laoResource;
}
@Override
public void setLAOResource(TransactionalResource h) {
laoResource = h;
}
boolean isImportedTransaction() {
return imported;
}
synchronized void putUserResource(Object key, Object value) {
if (userResourceMap == null) {
userResourceMap = new HashMap<>();
}
userResourceMap.put(key, value);
}
synchronized Object getUserResource(Object key) {
if (userResourceMap == null) {
return null;
}
return userResourceMap.get(key);
}
void registerInterposedSynchronization(Synchronization sync)
throws RollbackException,
SystemException {
interposedSyncs.add(sync);
if (jtsTx != null) {
jtsTx.registerInterposedSynchronization(sync);
}
}
void setComponentName(String componentName) {
this.componentName = componentName;
}
String getComponentName() {
return componentName;
}
synchronized void addResourceName(String resourceName) {
if (resourceNames == null) {
resourceNames = new ArrayList<>();
}
if( !resourceNames.contains(resourceName) ) {
resourceNames.add(resourceName);
}
}
synchronized List getResourceNames() {
return resourceNames;
}
@Override
public void addTxEntityManagerMapping(EntityManagerFactory emf,
SimpleResource em) {
getTxEntityManagerMap().put(emf, em);
}
@Override
public SimpleResource getTxEntityManagerResource(EntityManagerFactory emf) {
return getTxEntityManagerMap().get(emf);
}
private Map
getTxEntityManagerMap() {
if( txEntityManagerMap == null ) {
txEntityManagerMap = new HashMap<>();
}
return txEntityManagerMap;
}
protected void onTxCompletion(boolean status) {
if( txEntityManagerMap == null ) {
return;
}
for (Map.Entry entry :
getTxEntityManagerMap().entrySet()) {
SimpleResource em = entry.getValue();
if (em.isOpen()) {
try {
em.close();
} catch (Throwable th) {
if (_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE, "Exception while closing em.", th);
}
}
}
}
}
@Override
public void addExtendedEntityManagerMapping(EntityManagerFactory emf,
SimpleResource em) {
getExtendedEntityManagerMap().put(emf, em);
}
@Override
public void removeExtendedEntityManagerMapping(EntityManagerFactory emf) {
getExtendedEntityManagerMap().remove(emf);
}
@Override
public SimpleResource getExtendedEntityManagerResource(EntityManagerFactory emf) {
return getExtendedEntityManagerMap().get(emf);
}
private Map
getExtendedEntityManagerMap() {
if( extendedEntityManagerMap == null ) {
extendedEntityManagerMap = new HashMap<>();
}
return extendedEntityManagerMap;
}
@Override
public boolean isLocalTx() {
return (jtsTx==null);
}
void setJTSTx(TransactionInternal jtsTx) throws RollbackException, SystemException {
// Remember the status from this transaction
boolean marked_for_rollback = isRollbackOnly();
this.jtsTx = jtsTx;
if ( !commitStarted ) {
// register syncs
for ( int i=0; i
