log.debug("Enciphering found, wrapping in DataOutputStream");

        encryptingLogFile = new DataOutputStream(encipheringOutputStream);

      }

      key.event = OPEN;

      key.tserverSession = filename;

      key.filename = filename;

      write(key, EMPTY);

      sync.invoke(logFile);

  }

  public synchronized void defineTablet(int seq, int tid, KeyExtent tablet) throws IOException {

    // write this log to the METADATA table

    key.event = DEFINE_TABLET;

    key.seq = seq;

    key.tid = tid;

    key.tablet = tablet;

    try {

  public LoggerOperation logManyTablets(List<TabletMutations> mutations) throws IOException {

    List<Pair<LogFileKey,LogFileValue>> data = new ArrayList<Pair<LogFileKey,LogFileValue>>();

    for (TabletMutations tabletMutations : mutations) {

      key.event = MANY_MUTATIONS;

      key.seq = tabletMutations.getSeq();

      key.tid = tabletMutations.getTid();

      LogFileValue value = new LogFileValue();

      value.mutations = tabletMutations.getMutations();

    return logFileData(data);

  }

  public LoggerOperation minorCompactionFinished(int seq, int tid, String fqfn) throws IOException {

    key.event = COMPACTION_FINISH;

    key.seq = seq;

    key.tid = tid;

    return logFileData(Collections.singletonList(new Pair<LogFileKey,LogFileValue>(key, EMPTY)));

  }

    return logFileData(Collections.singletonList(new Pair<LogFileKey,LogFileValue>(key, EMPTY)));

  }

  public LoggerOperation minorCompactionStarted(int seq, int tid, String fqfn) throws IOException {

    key.event = COMPACTION_START;

    key.seq = seq;

    key.tid = tid;

    key.filename = fqfn;

    return logFileData(Collections.singletonList(new Pair<LogFileKey,LogFileValue>(key, EMPTY)));

    final DFSLoggerInputStreams streams = DfsLogger.readHeaderAndReturnStream(volumeManager, path, configuration);

    final DataInputStream input = streams.getDecryptingInputStream();

    final LogFileValue value = new LogFileValue();

    int read = 0;

    while (true) {

      try {

        value.readFields(input);

        read++;

      } catch (EOFException ex) {

        break;

      }

    public final LogFileKey key;

    public final LogFileValue value;

    KeyValue() {

      value = new LogFileValue();

    }

    for (String path : tabletFiles)

      suffixes.add(getPathSuffix(path));

    // Scan for tableId for this extent (should always be in the log)

    LogFileValue value = new LogFileValue();

    int tid = -1;

    if (!reader.next(key, value))

      throw new EmptyMapFileException();

    if (key.event != OPEN)

      throw new RuntimeException("First log entry value is not OPEN");

   

    if (key.tserverSession.compareTo(lastStartToFinish.tserverSession) != 0) {

      if (lastStartToFinish.compactionStatus == Status.LOOKING_FOR_FINISH)

        throw new RuntimeException("COMPACTION_FINISH (without preceding COMPACTION_START) is not followed by a successful minor compaction.");

      lastStartToFinish.update(key.tserverSession);

    }

    KeyExtent alternative = extent;

    if (extent.isRootTablet()) {

      alternative = RootTable.OLD_EXTENT;

    }

   

   

    // find the maximum tablet id... because a tablet may leave a tserver and then come back, in which case it would have a different tablet id

    // for the maximum tablet id, find the minimum sequence #... may be ok to find the max seq, but just want to make the code behave like it used to

    while (reader.next(key, value)) {

      // LogReader.printEntry(entry);

      if (key.event != DEFINE_TABLET)

        break;

      if (key.tablet.equals(extent) || key.tablet.equals(alternative)) {

        if (tid != key.tid) {

          tid = key.tid;

          defineKey = key;

        }

      }

    }

    if (tid < 0) {

      throw new UnusedException();

    return tid;

  }

 

  private void playbackMutations(MultiReader reader, int tid, LastStartToFinish lastStartToFinish, MutationReceiver mr) throws IOException {

    LogFileValue value = new LogFileValue();

   

    // Playback mutations after the last stop to finish

    log.info("Scanning for mutations starting at sequence number " + lastStartToFinish.seq + " for tid " + tid);

    key.event = MUTATION;

        log.debug("Enciphering found, wrapping in DataOutputStream");

        encryptingLogFile = new DataOutputStream(encipheringOutputStream);

      }

      key.event = OPEN;

      key.tserverSession = filename;

      key.filename = filename;

      write(key, EMPTY);

      sync.invoke(logFile);