package org.apache.ojb.odmg;

 /* Copyright 2002-2005 The Apache Software Foundation

  *

  * 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.

  */

 import org.apache.ojb.broker.OJBRuntimeException;

 import org.apache.ojb.broker.PBFactoryException;

 import org.apache.ojb.broker.PBKey;

 import org.apache.ojb.broker.PersistenceBroker;

 import org.apache.ojb.broker.PersistenceBrokerFactory;

 import org.apache.ojb.broker.util.logging.Logger;

 import org.apache.ojb.broker.util.logging.LoggerFactory;

 import org.odmg.Transaction;

 public final class PBCapsule

 {

     private static Logger log = LoggerFactory.getLogger(PBCapsule.class);

     PersistenceBroker broker;

     PBKey pbKey;

     Transaction tx;

     boolean needsTxCommit = false;

     boolean needsPBCommit = false;

     boolean isIlleagal = false;

     public PBCapsule(final PBKey pbKey, final Transaction tx)

     {

         this.tx = tx;

         this.pbKey = pbKey;

         prepare();

     }

     public PersistenceBroker getBroker()

     {

         if(isIlleagal) throw new OJBRuntimeException("You could not reuse PBCapsule after destroy");

         return broker;

     }

     private void prepare()

     {

         if(isIlleagal) throw new OJBRuntimeException("You could not reuse PBCapsule after destroy");

         // we allow queries even if no ODMG transaction is running.

         // thus we use direct access to PBF via the given PBKey to

         // get a PB instance

         if (tx == null)

         {

             if (log.isDebugEnabled())

                 log.debug("No running transaction found, try to get " +

                         "PersistenceBroker instance via PBKey " + pbKey);

             broker = obtainBroker();

             // begin tx on the PB instance

             if (!broker.isInTransaction())

             {

                 broker.beginTransaction();

                 needsPBCommit = true;

             }

         }

         else

         {

             // we allow to work with unopened transactions.

             // we assume that such a tx is to be closed after performing the query

             if (!tx.isOpen())

             {

                 tx.begin();

                 needsTxCommit = true;

             }

             // obtain a broker instance from the current transaction

             broker = ((HasBroker) tx).getBroker();

         }

     }

     public void destroy()

     {

         if (needsTxCommit)

         {

             if (log.isDebugEnabled()) log.debug("Indicated to commit tx");

             tx.commit();

         }

         else if (needsPBCommit)

         {

             if (log.isDebugEnabled()) log.debug("Indicated to commit PersistenceBroker");

             try

             {

                 broker.commitTransaction();

             }

             finally

             {

                 if (broker != null) broker.close();

             }

         }

         isIlleagal = true;

         needsTxCommit = false;

         needsPBCommit = false;

     }

     /**

      * Used to get PB, when no tx is running.

      */

     private PersistenceBroker obtainBroker()

     {

         PersistenceBroker _broker;

         try

         {

             if (pbKey == null)

             {

                 //throw new OJBRuntimeException("Not possible to do action, cause no tx runnning and no PBKey is set");

                 log.warn("No tx runnning and PBKey is null, try to use the default PB");

                 _broker = PersistenceBrokerFactory.defaultPersistenceBroker();

             }

             else

             {

                 _broker = PersistenceBrokerFactory.createPersistenceBroker(pbKey);

             }

         }

         catch (PBFactoryException e)

         {

             log.error("Could not obtain PB for PBKey " + pbKey, e);

             throw new OJBRuntimeException("Unexpected micro-kernel exception", e);

         }

         return _broker;

     }

 }