/**

  *

  * Copyright 2004 Hiram Chirino

  *

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

  *

  **/

 package org.activeio.journal.active;

 import java.io.File;

 import java.io.IOException;

 import java.io.InterruptedIOException;

 import java.lang.reflect.InvocationTargetException;

 import org.activeio.Disposable;

 import org.activeio.Packet;

 import org.activeio.journal.InvalidRecordLocationException;

 import org.activeio.journal.Journal;

 import org.activeio.journal.JournalEventListener;

 import org.activeio.journal.RecordLocation;

 import org.activeio.packet.ByteArrayPacket;

 import org.activeio.packet.ByteBufferPacketPool;

 import EDU.oswego.cs.dl.util.concurrent.FutureResult;

 import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;

 import EDU.oswego.cs.dl.util.concurrent.ThreadFactory;

 /**

  * A high speed Journal implementation. Inspired by the ideas of the <a

  * href="http://howl.objectweb.org/">Howl </a> project but tailored to the needs

  * of ActiveMQ. <p/>This Journal provides the following features:

  * <ul>

  * <li>Conncurrent writes are batched into a single write/force done by a

  * background thread.</li>

  * <li>Uses preallocated logs to avoid disk fragmentation and performance

  * degregation.</li>

  * <li>The number and size of the preallocated logs are configurable.</li>

  * <li>Uses direct ByteBuffers to write data to log files.</li>

  * <li>Allows logs to grow in case of an overflow condition so that overflow

  * exceptions are not not thrown. Grown logs that are inactivated (due to a new

  * mark) are resized to thier original size.</li>

  * <li>No limit on the size of the record written to the journal</li>

  * <li>Should be possible to extend so that multiple physical disk are used

  * concurrently to increase throughput and decrease latency.</li>

  * </ul>

  * <p/>

  * 

  * @version $Revision: 1.1 $

  */

     public static final int DEFAULT_POOL_SIZE = Integer.parseInt(System.getProperty("org.activeio.journal.active.DefaultPoolSize", ""+(5)));

     public static final int DEFAULT_PACKET_SIZE = Integer.parseInt(System.getProperty("org.activeio.journal.active.DefaultPacketSize", ""+(1024*1024*4)));

     static final private int OVERFLOW_RENOTIFICATION_DELAY = 500;

     private boolean disposed = false;

     // The id of the current log file that is being filled.

     private int appendLogFileId = 0;

     // The offset in the current log file that is being filled.

     private int appendLogFileOffset = 0;

     // Used to batch writes together.

     private BatchedWrite pendingBatchWrite;

     private Location lastMarkedLocation;

     private LogFileManager file;

     private QueuedExecutor executor;

     private int rolloverFence;

     private JournalEventListener eventListener;

     private ByteBufferPacketPool packetPool;

     private long overflowNotificationTime = System.currentTimeMillis();

     private Packet markPacket = new ByteArrayPacket(new byte[Location.SERIALIZED_SIZE]);

     }

     }

             }

         });

     }

     }

             // The following synchronized block is the bottle neck of the journal.  Make this

             // code faster and the journal should speed up.

                 }

                 // Create our record

                 // Piggy back the packet on the pending write batch.

                 // Update where the next record will land.

             }

             }

         } catch (IOException e) {

         } catch (InterruptedException e) {

         } catch (Throwable e) {

         }

     }

     /**

      * @param record

      * @return

      * @throws InterruptedException

      */

         // Load the write batch up with data from our record.

         // it may take more than one write batch if the record is large.

             // Do we need another BatchWrite?

             }

             // Can we continue to use the pendingBatchWrite?

                         } catch (InterruptedException e) {

                         }

                     }

                 });

             }

         }

     }

     /**

      * This is a blocking call

      * 

      * @param write

      * @throws InterruptedException

      */

         // Stop other threads from appending more pendingBatchWrite.

         // Do the write.

         } catch (Throwable e) {

         } finally {

         }

     }

     /**

      * 

      */

         // See if we need to issue an overflow notification.

                 && overflowNotificationTime + OVERFLOW_RENOTIFICATION_DELAY < System.currentTimeMillis()) {

             // We need to send an overflow notification to free up

             // some logFiles.

         }

         // Is it time to roll over?

             // Can we roll over?

                 // don't delay the next overflow notification.

             } else {

                             } catch (Throwable e) {

                             }

                         }

                     });

                 } catch (InterruptedException e) {

                 } catch (InvocationTargetException e) {

                                 .getTargetException());

                 }

             }

         }

     }

     /**

      * This is a blocking call

      */

     }

     /**

      * @param recordLocator

      * @param force

      * @return

      * @throws InvalidRecordLocationException

      * @throws IOException

      * @throws InterruptedException

      */

             IOException {

     }

     /**

      * @return

      */

     }

     /**

      * @param lastLocation

      * @return

      * @throws IOException

      * @throws InvalidRecordLocationException

      */

             InvalidRecordLocationException {

             } else {

             }

         }

         // Run this in the queued executor thread.

                     } catch (Throwable e) {

                     }

                 }

             });

         } catch (InterruptedException e) {

         } catch (InvocationTargetException e) {

         }

     }

                     .getTargetException());

     }

     }

     /**

      * @param location

      * @return

      * @throws InvalidRecordLocationException

      * @throws IOException

      */

         // Run this in the queued executor thread.

                     } catch (Throwable e) {

                     }

                 }

             });

         } catch (InterruptedException e) {

         } catch (InvocationTargetException e) {

                         .getTargetException());

         }

     }

     }

     /**

      * @deprecated @see #dispose()

      */

     }

     /**

      */

     }

     /**

      * @return

      */

     }

     }

     }

 }