/// <summary> /// Method DoReleaseConnection /// </summary> /// <param name="container">An ObjectContainer</param> /// <param name="dataSource">An IDb4oDataSource</param> private static void DoDisposeConnection(ObjectContainer container, IDb4oDataSource dataSource) { logger.Debug("DoDisposeConnection"); if (container == null) { logger.Debug("Container is null, doing nothing"); return; } if (dataSource != null) { logger.Debug("Data Source is not null, trying to release"); ObjectContainerHolder holder = (ObjectContainerHolder)TransactionSynchronizationManager.GetResource(dataSource); if (holder != null) { logger.Debug("holder is not null, releasing"); // should we make sure the connection is the right one ? holder.Released(); // should not go further since we are in a transactional context // => No connection closing directly return; } logger.Debug("No transaction, closing the container"); // no transactional context so // close the container container.close(); } }
/// <summary> /// Return the current transaction object. /// </summary> /// <returns>The current transaction object.</returns> /// <exception cref="Spring.Transaction.CannotCreateTransactionException"> /// If transaction support is not available. /// </exception> /// <exception cref="Spring.Transaction.TransactionException"> /// In the case of lookup or system errors. /// </exception> protected override Object DoGetTransaction() { logger.Debug("Do Get Transaction"); Db4oTransactionObject txObject = new Db4oTransactionObject(); ObjectContainerHolder contHolder = (ObjectContainerHolder)TransactionSynchronizationManager.GetResource(_DataSource); txObject.ObjectContainerHolder = contHolder; return(txObject); }
/// <summary> /// Suspend the resources of the current transaction. /// </summary> /// <param name="transaction"> /// Transaction object returned by /// <see cref="Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>. /// </param> /// <returns> /// An object that holds suspended resources (will be kept unexamined for passing it into /// <see cref="Spring.Transaction.Support.AbstractPlatformTransactionManager.DoResume"/>.) /// </returns> /// <remarks> /// Transaction synchronization will already have been suspended. /// </remarks> /// <exception cref="Spring.Transaction.IllegalTransactionStateException"> /// If suspending is not supported by the transaction manager implementation. /// </exception> /// <exception cref="Spring.Transaction.TransactionException"> /// in case of system errors. /// </exception> protected override Object DoSuspend(Object transaction) { logger.Debug("Do Suspend"); Db4oTransactionObject txObject = (Db4oTransactionObject)transaction; txObject.ObjectContainerHolder = null; ObjectContainerHolder containerHolder = (ObjectContainerHolder)TransactionSynchronizationManager.GetResource(_DataSource); return(new SuspendedResourcesHolder(containerHolder)); }
/// <summary> /// Method DoGetConnection does the actual Connection creation/recuperation /// It throws the orgiginal DB4o Exceptions /// </summary> /// <param name="dataSource">An IDb4oDataSource</param> /// <returns>An ObjectContainer</retutns> private static ObjectContainer DoGetConnection(IDb4oDataSource dataSource) { logger.Debug("Do Get Connection"); logger.Debug("GetResource from TransactionSynchronizationManager"); ObjectContainerHolder holder = (ObjectContainerHolder )TransactionSynchronizationManager.GetResource(dataSource); ObjectContainer container; if (holder != null) { logger.Debug("ObjectContainerHolder exists"); holder.Requested(); if (holder.ObjectContainer == null) { logger.Debug("No connection inside the ObjectContainerHolder"); logger.Debug("Creating One"); holder.ObjectContainer = dataSource.GetConnection(); } container = holder.ObjectContainer; } else { // the connection should be created logger.Debug("The Holder does not exist. It will be created"); container = dataSource.GetConnection(); if (TransactionSynchronizationManager.SynchronizationActive) { logger.Debug("Registerbe increaseing transaction synchronization"); logger.Debug("Will use the same connection for further DB4o actions within the transaction"); logger.Debug("Thread-bound object will get removed by synchronization at transaction completion"); holder = new ObjectContainerHolder(container); holder.SynchronizedWithTransaction = true; holder.Requested(); TransactionSynchronizationManager.RegisterSynchronization( new ObjectContainerSynchronization(holder, dataSource)); TransactionSynchronizationManager.BindResource(dataSource, holder); } } return(container); }
/// <summary> /// Begin a new transaction with the given transaction definition. /// </summary> /// <param name="transaction"> /// Transaction object returned by /// <see cref="Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>. /// </param> /// <param name="definition"> /// <see cref="Spring.Transaction.ITransactionDefinition"/> instance, describing /// propagation behavior, isolation level, timeout etc. /// </param> /// <remarks> /// Does not have to care about applying the propagation behavior, /// as this has already been handled by this abstract manager. /// </remarks> /// <exception cref="Spring.Transaction.TransactionException"> /// In the case of creation or system errors. /// </exception> protected override void DoBegin(Object transaction, ITransactionDefinition definition) { logger.Debug("Do Begin Transaction"); if (definition.TransactionIsolationLevel != IsolationLevel.Unspecified) { logger.Error("Db4o Does not support Isolation Level"); throw new CannotCreateTransactionException("Db4o does not support an isolation level concept"); } try{ Db4oTransactionObject txObject = (Db4oTransactionObject)transaction; if (txObject.ObjectContainerHolder == null) { // use the given container logger.Warn("Are we supposed to be in this case ??"); ObjectContainer container = Db4oUtils.GetConnection(_DataSource); logger.Debug("Using given objectContainer [" + container + "] for the current thread transaction"); txObject.ObjectContainerHolder = new ObjectContainerHolder(container); } ObjectContainerHolder holder = txObject.ObjectContainerHolder; //holder. set readonly ?? if (definition.TransactionTimeout != -1) { logger.Debug("Setting Transaction Timeout : " + definition.TransactionTimeout); holder.TimeoutInSeconds = definition.TransactionTimeout; } } catch (Exception e) { logger.Error("Cannot create transaction"); throw new CannotCreateTransactionException("Cannot create transaction", e); } }
public ObjectContainerSynchronization(ObjectContainerHolder holder, IDb4oDataSource dataSource) { _Holder = holder; _DataSource = dataSource; }
public SuspendedResourcesHolder(ObjectContainerHolder containerHolder) { this._ObjectContainerHolder = containerHolder; }