public void setService(R service) { if ( this.service != null ) { if ( log.isDebugEnabled() ) { log.debug( "Overriding existing service binding [" + serviceRole.getName() + "]" ); } } this.service = service; } }
protected void resetConnection(boolean initiallyAutoCommit) { try { if ( initiallyAutoCommit ) { log.trace( "re-enabling auto-commit on JDBC Connection after completion of JDBC-based transaction" ); getConnectionForTransactionManagement().setAutoCommit( true ); status = TransactionStatus.NOT_ACTIVE; } } catch ( Exception e ) { log.debug( "Could not re-enable auto-commit on JDBC Connection after completion of JDBC-based transaction : " + e ); } }
if ( log.isTraceEnabled() ) { log.trace( String.format( "Registering named strategy selector [%s] : [%s] -> [%s]", if ( log.isDebugEnabled() ) { log.debug( String.format( "Registering named strategy selector [%s] : [%s] -> [%s] (replacing [%s])",
private List<Uid> convertToList(InputObjectState aa_uids) { List<Uid> uids = new ArrayList<Uid>(); boolean moreUids = true; while (moreUids) { Uid theUid = null; try { theUid = UidHelper.unpackFrom(aa_uids); if (theUid.equals(Uid.nullUid())) { moreUids = false; } else { Uid newUid = new Uid(theUid); if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("found transaction " + newUid); } uids.add(newUid); } } catch (IOException ex) { moreUids = false; } } return uids; }
/** * Adds an explicit (as opposed to discovered) strategy registration. * * @param strategyRegistration The strategy implementation registration. * @param <T> The type of the strategy. Used to make sure that the strategy and implementation are type * compatible. */ public <T> void addExplicitStrategyRegistration(StrategyRegistration<T> strategyRegistration) { if ( !strategyRegistration.getStrategyRole().isInterface() ) { // not good form... log.debug( "Registering non-interface strategy : " + strategyRegistration.getStrategyRole().getName() ); } if ( ! strategyRegistration.getStrategyRole().isAssignableFrom( strategyRegistration.getStrategyImplementation() ) ) { throw new StrategySelectionException( "Implementation class [" + strategyRegistration.getStrategyImplementation().getName() + "] does not implement strategy interface [" + strategyRegistration.getStrategyRole().getName() + "]" ); } explicitStrategyRegistrations.add( strategyRegistration ); }
@Override public synchronized Service registerService(Service service) { if (!_services.containsKey(service.getName())) { _services.put(service.getName(), new LinkedList<Service>()); } _services.get(service.getName()).add(service); if (_logger.isDebugEnabled()) { _logger.debug("Registered Service '" + service.getName() + "'."); } return service; }
if (member != null) { if (member.getUniqueEventID() > uniqueEventID) { logger.debug("The removeMember was issued before the node " + nodeId + " was started, ignoring call"); member = null; } else { if (logger.isTraceEnabled()) { logger.trace("removeMember " + this + " removing nodeID=" + nodeId +
/** * This is called periodically by the RecoveryManager */ public void periodicWorkFirstPass() { // Transaction type boolean AtomicActions = false ; // uids per transaction type InputObjectState aa_uids = new InputObjectState() ; try { if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("AtomicActionRecoveryModule first pass"); } AtomicActions = _recoveryStore.allObjUids( _transactionType, aa_uids ); } catch ( ObjectStoreException ex ) { tsLogger.i18NLogger.warn_recovery_AtomicActionRecoveryModule_1(ex); } if ( AtomicActions ) { _transactionUidVector = processTransactions( aa_uids ) ; } }
public AtomicActionRecoveryModule() { if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("AtomicActionRecoveryModule created"); } if (_recoveryStore == null) { _recoveryStore = StoreManager.getRecoveryStore(); } _transactionStatusConnectionMgr = new TransactionStatusConnectionManager() ; }
@Override public void close() throws ActiveMQException { if (closed) { logger.debug("Session was already closed, giving up now, this=" + this); return; } if (logger.isDebugEnabled()) { logger.debug("Calling close on session " + this); } try { closeChildren(); synchronized (producerCreditManager) { producerCreditManager.close(); } inClose = true; sessionContext.sessionClose(); } catch (Throwable e) { // Session close should always return without exception // Note - we only log at trace logger.trace("Failed to close session", e); } doCleanup(false); }
public TransactionImpl( TransactionCoordinator transactionCoordinator, ExceptionConverter exceptionConverter, AbstractSharedSessionContract session) { this.transactionCoordinator = transactionCoordinator; this.exceptionConverter = exceptionConverter; this.jpaCompliance = session.getFactory().getSessionFactoryOptions().getJpaCompliance(); this.session = session; if ( session.isOpen() && transactionCoordinator.isActive() ) { this.transactionDriverControl = transactionCoordinator.getTransactionDriverControl(); } else { LOG.debug( "TransactionImpl created on closed Session/EntityManager" ); } if ( LOG.isDebugEnabled() ) { LOG.debugf( "On TransactionImpl creation, JpaCompliance#isJpaTransactionComplianceEnabled == %s", jpaCompliance.isJpaTransactionComplianceEnabled() ); } }
public CachedRecoveredTransaction ( Uid actionUid, String theType ) { _theTransactionUid = new Uid (actionUid); _theTransactionType = theType; if (jtsLogger.logger.isDebugEnabled()) { jtsLogger.logger.debug("CachedRecoveredTransaction created ["+_theTransactionUid+", "+_theTransactionType+"]"); } }
private List<Uid> convertToList(InputObjectState aa_uids) { List<Uid> uids = new ArrayList<Uid>(); boolean moreUids = true; while (moreUids) { Uid theUid = null; try { theUid = UidHelper.unpackFrom(aa_uids); if (theUid.equals(Uid.nullUid())) { moreUids = false; } else { Uid newUid = new Uid(theUid); if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("found transaction " + newUid); } uids.add(newUid); } } catch (IOException ex) { moreUids = false; } } return uids; }
public void addEvent(AbstractCollectionEvent event, Listener listener) { CollectionEntry collectionEntry = event.getSession() .getPersistenceContext() .getCollectionEntry(event.getCollection()); Serializable snapshot = collectionEntry.getSnapshot(); log.debug("add Event: " + event.getClass() + "; listener = " + listener.getClass() + "; snapshot = " + snapshot); listenersCalled.add(listener); events.add(event); snapshots.add(snapshot); }
private static void addJAXBMarshalTransformer(Class<?> outType, List<Transformer<?, ?>> transformers) throws SwitchYardException { Class<?> objectFactory = getObjectFactory(outType); if (objectFactory != null) { QName toType = getTypeXMLQName(outType, objectFactory); if (toType != null) { QName fromType = JavaTypes.toMessageType(outType); transformers.add(new JAXBMarshalTransformer(fromType, toType, outType.getPackage().getName(), false, false)); } else if (_log.isDebugEnabled()) { _log.debug(createMissingFactoryMethodMessage(outType, objectFactory)); } } }
@Override public void commit(final Xid xid, final boolean onePhase) throws XAException { if (logger.isTraceEnabled()) { logger.trace("call commit(xid=" + convert(xid)); logger.debug("Throwing oneFase RMFAIL on xid=" + xid, t); logger.debug("Throwing twoFase Retry on xid=" + xid, t);
/** * This is called periodically by the RecoveryManager */ public void periodicWorkFirstPass() { // Transaction type boolean AtomicActions = false ; // uids per transaction type InputObjectState aa_uids = new InputObjectState() ; try { if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("AtomicActionRecoveryModule first pass"); } AtomicActions = _recoveryStore.allObjUids( _transactionType, aa_uids ); } catch ( ObjectStoreException ex ) { tsLogger.i18NLogger.warn_recovery_AtomicActionRecoveryModule_1(ex); } if ( AtomicActions ) { _transactionUidVector = processTransactions( aa_uids ) ; } }
public AtomicActionRecoveryModule() { if (tsLogger.logger.isDebugEnabled()) { tsLogger.logger.debug("AtomicActionRecoveryModule created"); } if (_recoveryStore == null) { _recoveryStore = StoreManager.getRecoveryStore(); } _transactionStatusConnectionMgr = new TransactionStatusConnectionManager() ; }
private static void logAddOnShutdown() { if (logger.isDebugEnabled()) { logger.debug("Ordered executor has been gently shutdown at", new Exception("debug")); } }
if (logger.isTraceEnabled()) { logger.trace(this + "::FlowControl::Sending " + creditsToSend + " -1, for slow consumer"); if (logger.isDebugEnabled()) { logger.debug("Sending " + messageBytes + " from flow-control");