package org.apache.ojb.broker.util.sequence;
   
   /* 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 java.util.HashMap;
  import java.util.Map;
  
  import org.apache.commons.lang.SystemUtils;
  import org.apache.ojb.broker.Identity;
  import org.apache.ojb.broker.OptimisticLockException;
  import org.apache.ojb.broker.PersistenceBroker;
  import org.apache.ojb.broker.PersistenceBrokerFactory;
  import org.apache.ojb.broker.metadata.FieldDescriptor;
  import org.apache.ojb.broker.util.ObjectModification;
  import org.apache.ojb.broker.util.logging.Logger;
  import org.apache.ojb.broker.util.logging.LoggerFactory;
  
  /**
   * High/Low sequence manager implementation generates unique and continuous
   * id's (during runtime) by using sequences to avoid database access.
   * <br/>
   *
   * <p>
   * Implementation configuration properties:
   * </p>
   *
   * <table cellspacing="2" cellpadding="2" border="3" frame="box">
   * <tr>
   *     <td><strong>Property Key</strong></td>
   *     <td><strong>Property Values</strong></td>
   * </tr>
   * <tr>
   *     <td>seq.start</td>
   *     <td>
   *         Set the start index of used sequences (e.g. set 100000, id generation starts with 100001).
   *         Default start index is <em>1</em>.
   *    </td>
   * </tr>
   * <tr>
   *     <td>grabSize</td>
   *     <td>
   *         Integer entry determines the
   *         number of IDs allocated within the
   *         H/L sequence manager implementation.
   *         Default was '20'.
   *    </td>
   * </tr>
   * <tr>
   *     <td>autoNaming</td>
   *     <td>
   *          Default was 'true'. If set 'true' OJB try to build a
   *          sequence name automatic if none found in field-descriptor
   *          and set this generated name as <code>sequence-name</code>
   *          in field-descriptor. If set 'false' OJB throws an exception
   *          if none sequence name was found in field-descriptor.
   *    </td>
   * </tr>
   * <tr>
   *     <td>globalSequenceId</td>
   *     <td>
   *         Deprecated! If set 'true' implementation use global unique
   *         id's for all fields. Default was 'false'.
   *    </td>
   * </tr>
   * <tr>
   *     <td>globalSequenceStart</td>
   *     <td>
   *         <em>Deprecated, use property 'seq.start'.</em> Set the start index of used global id
   *         generation (e.g. set 100000, id generation starts with 100001)
   *    </td>
   * </tr>
   *  <tr>
   *     <td>sequenceStart</td>
   *     <td>
   *         <em>Deprecated, use property 'seq.start'.</em> Set the start index of used
   *          sequences (e.g. set 100000, id generation starts with 100001). Default start index is <em>1</em>.
   *    </td>
   * </tr>
   * </table>
   *
   * <br/>
   * <p>
   * <b>Limitations:</b>
   * <ul>
   *	<li>Do NOT use this implementation in managed environment or
   * any comparable system where any connection was associated
  * with the running transaction.</li>
  * </ul>
  * </p>
  *
  *
  * <br/>
  * <br/>
  *
  *
  * @see org.apache.ojb.broker.util.sequence.SequenceManager
  * @see org.apache.ojb.broker.util.sequence.SequenceManagerFactory
  * @see org.apache.ojb.broker.util.sequence.SequenceManagerHelper
  *
  * @author <a href="mailto:armin@codeAuLait.de">Armin Waibel</a>
  * @version $Id: SequenceManagerHighLowImpl.java,v 1.1 2007-08-24 22:17:29 ewestfal Exp $
  */
 public class SequenceManagerHighLowImpl extends AbstractSequenceManager
 {
     private static Logger log = LoggerFactory.getLogger(SequenceManagerHighLowImpl.class);
     /**
      * sequence name used for global id generation.
      */
     private static final String GLOBAL_SEQUENCE_NAME = "global - default sequence name";
     public static final String PROPERTY_GRAB_SIZE = "grabSize";
     public static final String PROPERTY_GLOBAL_SEQUENCE_ID = "globalSequenceId";
     public static final String PROPERTY_GLOBAL_SEQUENCE_START = "globalSequenceStart";
 
     protected static Map sequencesDBMap = new HashMap();
 
     protected boolean useGlobalSequenceIdentities;
     protected int grabSize;
     protected long sequenceStart;
     protected int attempts;
 
     public SequenceManagerHighLowImpl(PersistenceBroker broker)
     {
         super(broker);
         Long start = SequenceManagerHelper.getSeqStart(getConfigurationProperties());
         sequenceStart = start != null ? start.longValue() : 1;
         grabSize = Integer.parseInt(getConfigurationProperty(PROPERTY_GRAB_SIZE, "20"));
         useGlobalSequenceIdentities = Boolean.getBoolean(getConfigurationProperty(PROPERTY_GLOBAL_SEQUENCE_ID, "false"));
         // support for deprecated properties
         long globalSequenceStart = Long.parseLong(getConfigurationProperty(PROPERTY_GLOBAL_SEQUENCE_START, "1"));
         if(useGlobalSequenceIdentities && globalSequenceStart > sequenceStart)
         {
             sequenceStart = globalSequenceStart;
         }
     }
 
     protected long getUniqueLong(FieldDescriptor field) throws SequenceManagerException
     {
         HighLowSequence seq;
         String sequenceName = buildSequenceName(field);
         synchronized (SequenceManagerHighLowImpl.class)
         {
             // try to find sequence
             seq = getSequence(sequenceName);
 
             if (seq == null)
             {
                 // not found, get sequence from database or create new
                 seq = getSequence(getBrokerForClass(), field, sequenceName);
                 addSequence(sequenceName, seq);
             }
 
             // now we have a sequence
             long id = seq.getNextId();
             // seq does not have reserved IDs => catch new block of keys
             if (id == 0)
             {
                 seq = getSequence(getBrokerForClass(), field, sequenceName);
                 // replace old sequence!!
                 addSequence(sequenceName, seq);
                 id = seq.getNextId();
                 if (id == 0)
                 {
                     // something going wrong
                     removeSequence(sequenceName);
                     throw new SequenceManagerException("Sequence generation failed: " +
                             SystemUtils.LINE_SEPARATOR + "Sequence: " + seq +
                             ". Unable to build new ID, id was always 0." +
                             SystemUtils.LINE_SEPARATOR + "Thread: " + Thread.currentThread() +
                             SystemUtils.LINE_SEPARATOR + "PB: " + getBrokerForClass());
                 }
             }
             return id;
         }
     }
 
     /**
      * Returns last used sequence object or <code>null</code> if no sequence
      * was add for given sequence name.
      *
      * @param sequenceName Name of the sequence.
      * @return Sequence object or <code>null</code>
      */
     private HighLowSequence getSequence(String sequenceName)
     {
         HighLowSequence result = null;
         // now lookup the sequence map for calling DB
         Map mapForDB = (Map) sequencesDBMap.get(getBrokerForClass()
                 .serviceConnectionManager().getConnectionDescriptor().getJcdAlias());
         if(mapForDB != null)
         {
             result = (HighLowSequence) mapForDB.get(sequenceName);
         }
         return result;
     }
 
     /**
      * Put new sequence object for given sequence name.
      * @param sequenceName Name of the sequence.
      * @param seq The sequence object to add.
      */
     private void addSequence(String sequenceName, HighLowSequence seq)
     {
         // lookup the sequence map for calling DB
         String jcdAlias = getBrokerForClass()
                 .serviceConnectionManager().getConnectionDescriptor().getJcdAlias();
         Map mapForDB = (Map) sequencesDBMap.get(jcdAlias);
         if(mapForDB == null)
         {
             mapForDB = new HashMap();
         }
         mapForDB.put(sequenceName, seq);
         sequencesDBMap.put(jcdAlias, mapForDB);
     }
 
     /**
      * Remove the sequence for given sequence name.
      *
      * @param sequenceName Name of the sequence to remove.
      */
     protected void removeSequence(String sequenceName)
     {
         // lookup the sequence map for calling DB
         Map mapForDB = (Map) sequencesDBMap.get(getBrokerForClass()
                 .serviceConnectionManager().getConnectionDescriptor().getJcdAlias());
         if(mapForDB != null)
         {
             synchronized(SequenceManagerHighLowImpl.class)
             {
                 mapForDB.remove(sequenceName);
             }
         }
     }
 
     protected HighLowSequence getSequence(PersistenceBroker brokerForSequence,
                                         FieldDescriptor field,
                                         String sequenceName)  throws SequenceManagerException
     {
         HighLowSequence newSequence = null;
         PersistenceBroker internBroker = null;
         try
         {
             /*
             arminw:
             we use a new internBroker instance, because we run into problems
             when current internBroker was rollback, then we have new sequence
             in memory, but not in database and a concurrent thread will
             get the same sequence.
             Thus we use a new internBroker instance (with new connection) to
             avoid this problem.
             */
             internBroker = PersistenceBrokerFactory.createPersistenceBroker(brokerForSequence.getPBKey());
             internBroker.beginTransaction();
 
             newSequence = lookupStoreSequence(internBroker, field, sequenceName);
 
             internBroker.commitTransaction();
 
             if (log.isDebugEnabled()) log.debug("new sequence was " + newSequence);
         }
         catch(Exception e)
         {
             log.error("Can't lookup new HighLowSequence for field "
                     + (field != null ? field.getAttributeName() : null)
                     + " using sequence name " + sequenceName, e);
             if(internBroker != null && internBroker.isInTransaction()) internBroker.abortTransaction();
             throw new SequenceManagerException("Can't build new sequence", e);
         }
         finally
         {
             attempts = 0;
             if (internBroker != null) internBroker.close();
         }
         return newSequence;
     }
 
     protected HighLowSequence lookupStoreSequence(PersistenceBroker broker, FieldDescriptor field, String seqName)
     {
         HighLowSequence newSequence;
         boolean needsInsert = false;
 
         Identity oid = broker.serviceIdentity().buildIdentity(HighLowSequence.class, seqName);
         // first we lookup sequence object in database
         newSequence = (HighLowSequence) broker.getObjectByIdentity(oid);
 
         //not in db --> we have to store a new sequence
         if (newSequence == null)
         {
             if (log.isDebugEnabled())
             {
                 log.debug("sequence for field " + field + " not found in db, store new HighLowSequence");
             }
             /*
             here we lookup the max key for the given field in system
             */
             // !!! here we use current broker instance to avoid deadlock !!!
             long maxKey = getMaxKeyForSequence(getBrokerForClass(), field);
 
             newSequence = newSequenceObject(seqName, field);
             newSequence.setMaxKey(maxKey);
             needsInsert = true;
         }
         // maybe property 'sequenceStart' was changed, so we check maxKey against
         // current set sequence start index
         if(newSequence.getMaxKey() < sequenceStart)
         {
             newSequence.setMaxKey(sequenceStart);
         }
 
         // set current grab size
         newSequence.setGrabSize(grabSize);
 
         //grab the next key scope
         newSequence.grabNextKeySet();
 
         //store the sequence to db
         try
         {
             if(needsInsert) broker.store(newSequence, ObjectModification.INSERT);
             else broker.store(newSequence, ObjectModification.UPDATE);
         }
         catch (OptimisticLockException e)
         {
             // we try five times to get a new sequence
             if(attempts < 5)
             {
                 log.info("OptimisticLockException was thrown, will try again to store sequence. Sequence was "+newSequence);
                 attempts++;
                 newSequence = lookupStoreSequence(broker, field, seqName);
             }
             else throw e;
         }
         return newSequence;
     }
 
     protected HighLowSequence newSequenceObject(String sequenceName,
                                               FieldDescriptor field)
     {
         HighLowSequence seq = new HighLowSequence();
         seq.setName(sequenceName);
         seq.setGrabSize(grabSize);
         return seq;
     }
 
     protected long getMaxKeyForSequence(PersistenceBroker broker,
                                         FieldDescriptor field)
     {
         long maxKey;
         if (useGlobalSequenceIdentities)
         {
             maxKey = sequenceStart;
         }
         else
         {
             /*
             here we lookup the max key for the given field in system
             */
             maxKey = SequenceManagerHelper.getMaxForExtent(broker, field);
             // check against start index
             maxKey = sequenceStart > maxKey ? sequenceStart : maxKey;
         }
         return maxKey;
     }
 
     private String buildSequenceName(FieldDescriptor field) throws SequenceManagerException
     {
         String seqName;
         if (useGlobalSequenceIdentities)
         {
             seqName = GLOBAL_SEQUENCE_NAME;
         }
         else
         {
             seqName = calculateSequenceName(field);
         }
         return seqName;
     }
 }