content: /*
   *
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you 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.apache.bookkeeper.bookie;
  
  import io.netty.buffer.ByteBuf;
  import java.io.File;
  import java.io.IOException;
  import java.util.List;
  import org.apache.bookkeeper.bookie.DefaultEntryLogger.BufferedLogChannel;
  
  interface EntryLogManager {
  
      /*
       * add entry to the corresponding entrylog and return the position of
       * the entry in the entrylog
       */
      long addEntry(long ledger, ByteBuf entry, boolean rollLog) throws IOException;
  
      /*
       * gets the active logChannel with the given entryLogId. null if it is
       * not existing.
       */
      BufferedLogChannel getCurrentLogIfPresent(long entryLogId);
  
      /*
       * Returns eligible writable ledger dir for the creation next entrylog
       */
      File getDirForNextEntryLog(List<File> writableLedgerDirs);
  
      /*
       * Do the operations required for checkpoint.
       */
      void checkpoint() throws IOException;
  
      /*
       * flush both current and rotated logs.
       */
      void flush() throws IOException;
  
      /*
       * close current logs.
       */
      void close() throws IOException;
  
      /*
       * force close current logs.
       */
      void forceClose();
  
      /*
       * prepare entrylogger/entrylogmanager before doing SortedLedgerStorage
       * Checkpoint.
       */
      void prepareSortedLedgerStorageCheckpoint(long numBytesFlushed) throws IOException;
  
      /*
       * this method should be called before doing entrymemtable flush, it
       * would save the state of the entrylogger before entrymemtable flush
       * and commitEntryMemTableFlush would take appropriate action after
       * entrymemtable flush.
       */
      void prepareEntryMemTableFlush();
  
      /*
       * this method should be called after doing entrymemtable flush,it would
       * take appropriate action after entrymemtable flush depending on the
       * current state of the entrylogger and the state of the entrylogger
       * during prepareEntryMemTableFlush.
       *
       * It is assumed that there would be corresponding
       * prepareEntryMemTableFlush for every commitEntryMemTableFlush and both
       * would be called from the same thread.
       *
       * returns boolean value indicating whether EntryMemTable should do checkpoint
       * after this commit method.
       */
      boolean commitEntryMemTableFlush() throws IOException;
  
      /*
       * creates new separate log for compaction.
       */
      BufferedLogChannel createNewLogForCompaction() throws IOException;
  }
  