コード例 #1
1
  private void reportProblem(Exception e) {

    StringBuilder sb = new StringBuilder();
    sb.append("Halted log file reading at file 0x")
        .append(Long.toHexString(window.currentFileNum()))
        .append(" offset 0x")
        .append(Long.toHexString(nextEntryOffset))
        .append(" offset(decimal)=")
        .append(nextEntryOffset)
        .append(" prev=0x")
        .append(Long.toHexString(currentEntryPrevOffset));

    if (currentEntryHeader != null) {
      LogEntryType problemType = LogEntryType.findType(currentEntryHeader.getType());
      sb.append(":\nentry=")
          .append(problemType)
          .append("type=")
          .append(currentEntryHeader.getType())
          .append(",version=")
          .append(currentEntryHeader.getVersion())
          .append(")\nprev=0x")
          .append(Long.toHexString(currentEntryPrevOffset))
          .append("\nsize=")
          .append(currentEntryHeader.getItemSize())
          .append("\nNext entry should be at 0x")
          .append(
              Long.toHexString(
                  nextEntryOffset
                      + currentEntryHeader.getSize()
                      + currentEntryHeader.getItemSize()));
    }

    LoggerUtils.traceAndLogException(envImpl, "FileReader", "readNextEntry", sb.toString(), e);
  }
コード例 #2
0
  /**
   * Add the entry bytes to the checksum and check the value. This method must be called with the
   * buffer positioned at the start of the entry.
   */
  private void validateChecksum(ByteBuffer dataBuffer, boolean isChecksumTarget)
      throws ChecksumException {

    if (!doChecksumOnRead) {
      return;
    }

    if (!isChecksumTarget) {
      return;
    }

    cksumValidator.update(dataBuffer, currentEntryHeader.getItemSize());
    cksumValidator.validate(
        currentEntryHeader.getChecksum(), window.currentFileNum(), currentEntryOffset);
  }
コード例 #3
0
  /** @return true if the current entry is part of replication stream. */
  public boolean entryIsReplicated() {

    if (currentEntryHeader == null) {
      throw EnvironmentFailureException.unexpectedState(
          "entryIsReplicated should not be used before reader is " + "initialized");
    }
    return currentEntryHeader.getReplicated();
  }
コード例 #4
0
  /**
   * Read the basic log entry header, leaving the buffer mark at the beginning of the checksummed
   * header data.
   */
  private void readBasicHeader(ByteBuffer dataBuffer) throws ChecksumException, DatabaseException {

    /* Read the header for this entry. */
    currentEntryHeader = new LogEntryHeader(dataBuffer, window.logVersion);

    /*
     * currentEntryPrevOffset is a separate field, and is not obtained
     * directly from the currentEntryHeader, because it is initialized and
     * used before any log entry was read.
     */
    currentEntryPrevOffset = currentEntryHeader.getPrevOffset();
  }
コード例 #5
0
  private void startChecksum(ByteBuffer dataBuffer, boolean isChecksumTarget)
      throws ChecksumException {

    if (!doChecksumOnRead) {
      return;
    }

    if (!isChecksumTarget) {
      return;
    }

    /* Clear out any previous data. */
    cksumValidator.reset();

    int originalPosition = threadSafeBufferPosition(dataBuffer);
    if (currentEntryHeader.isInvisible()) {

      /*
       * Turn off invisibility so that the checksum will succeed. When
       * entries are made invisible, the checksum is not adjusted. Note
       * that the dataBuffer can leave the invisible bit transformed,
       * because the header has already been initialized, and this data
       * will never be read again.
       */
      LogEntryHeader.turnOffInvisible(
          dataBuffer, originalPosition - LogEntryHeader.MIN_HEADER_SIZE);
    }

    /* Position the buffer at the start of the data, after the checksum. */
    int headerSizeMinusChecksum = currentEntryHeader.getInvariantSizeMinusChecksum();
    int entryTypeStart = originalPosition - headerSizeMinusChecksum;
    threadSafeBufferPosition(dataBuffer, entryTypeStart);

    /* Load the validate with the header bytes. */
    cksumValidator.update(dataBuffer, headerSizeMinusChecksum);

    /* Move the data buffer back to the original position. */
    threadSafeBufferPosition(dataBuffer, originalPosition);
  }
コード例 #6
0
 /**
  * May be called by processEntry when it determines that the entry does not need to be
  * read/de-serialized.
  */
 protected void skipEntry(ByteBuffer entryBuffer) {
   threadSafeBufferPosition(
       entryBuffer, threadSafeBufferPosition(entryBuffer) + currentEntryHeader.getItemSize());
 }
コード例 #7
0
  /**
   * Variant of readNextEntry that throws FileNotFoundException and ChecksumException, rather than
   * wrapping them in an EnvironmentFailureException and invalidating the enviornment. This allows
   * users of this class (see cleaner.FileProcessor), and subclasses that override readNextEntry
   * (see ScavengerFileReader and LastFileReader), to handle these exceptions specially.
   */
  public final boolean readNextEntryAllowExceptions()
      throws FileNotFoundException, ChecksumException {

    boolean foundEntry = false;
    long savedCurrentEntryOffset = currentEntryOffset;
    long savedNextEntryOffset = nextEntryOffset;

    try {
      while ((!eof) && (!foundEntry)) {

        /* Read the invariant portion of the next header. */
        getLogEntryInReadBuffer();
        ByteBuffer dataBuffer = readData(LogEntryHeader.MIN_HEADER_SIZE, true); // collectData

        readBasicHeader(dataBuffer);

        boolean isTarget;
        boolean isChecksumTarget;
        boolean collectData;

        if (currentEntryHeader.isVariableLength()) {

          /*
           * For all variable length entries, init the checksum w/the
           * invariant portion of the header, before we know whether
           * the entry is a target for this reader.  This has
           * to be done before we read the variable portion of the
           * header, because readData() only guarantees that it
           * returns a dataBuffer that contains the next bytes that
           * are needed, and has no guarantee that it holds any bytes
           * that were previously read. The act of calling
           * readData() to obtain the optional portion may reset the
           * dataBuffer, and nudge the invariant part of the header
           * out of the buffer returned by readData()
           */
          startChecksum(dataBuffer);

          int optionalPortionLen = currentEntryHeader.getVariablePortionSize();

          /* Load the optional part of the header into a buffer. */
          dataBuffer = readData(optionalPortionLen, true);

          /*
           * Add to checksum while the buffer is positioned at
           * the start of the new bytes.
           */
          addToChecksum(dataBuffer, optionalPortionLen);

          /* Now read the optional bytes. */
          currentEntryHeader.readVariablePortion(dataBuffer);
        }

        /*
         * We've read the header of the next logrec. Move up our
         * offsets if we're moving forward. If we're moving
         * backwards, we set our offset before we read the header,
         * because we knew where the entry started.
         */
        if (forward) {
          currentEntryOffset = nextEntryOffset;
          nextEntryOffset +=
              currentEntryHeader.getSize()
                  + // header size
                  currentEntryHeader.getItemSize(); // item size
        }

        try {
          isTarget = isTargetEntry();

          isChecksumTarget = (isTarget || alwaysValidateChecksum);

          if (!currentEntryHeader.isVariableLength()) {
            startChecksum(dataBuffer, isChecksumTarget);
          }

          collectData = (isChecksumTarget && doChecksumOnRead) || isTarget;

          /*
           * Read in the body of the next entry. Note that even if
           * this isn't a targeted entry, we have to move the buffer
           * position along.
           */
          dataBuffer = readData(currentEntryHeader.getItemSize(), collectData);
        } catch (Throwable e) {
          if (forward) {
            currentEntryOffset = savedCurrentEntryOffset;
            nextEntryOffset = savedNextEntryOffset;
          }
          throw e;
        }

        /* Validate the log entry checksum. */
        validateChecksum(dataBuffer, isChecksumTarget);

        if (isTarget) {

          /*
           * For a target entry, call the subclass reader's
           * processEntry method to do whatever we need with the
           * entry.  It returns true if this entry is one that should
           * be returned.  Note that some entries, although targeted
           * and read, are not returned.
           */
          if (processEntry(dataBuffer)) {
            foundEntry = true;
            nRead++;
          }
        } else if (collectData) {

          /*
           * For a non-target entry that was validated, the buffer is
           * positioned at the start of the entry; skip over it.
           */
          skipEntry(dataBuffer);
        }
      }
    } catch (EOFException e) {
      eof = true;
    } catch (DatabaseException e) {
      eof = true;
      /* Report on error. */
      reportProblem(e);
      throw e;
    }

    return foundEntry;
  }
コード例 #8
0
 /** Returns the total size (including header) of the last entry read. */
 public int getLastEntrySize() {
   return currentEntryHeader.getEntrySize();
 }