Enum Events

  • All Implemented Interfaces:
    java.io.Serializable, java.lang.Comparable<Events>

    enum Events
    extends java.lang.Enum<Events>
    • Enum Constant Detail


        public static final Events DATA_INTEG_SERVICE_START
        Data integrity service has started It runs at an interval to check if a full integrity check is needed, and if so runs it.

        public static final Events DATA_INTEG_SERVICE_STOP
        Data integrity service has been stopped.

        public static final Events DATA_INTEG_SERVICE_UNCAUGHT_ERROR
        An exception was thrown on the data integrity service executor and never caught. This is a programmer error and should be reported as such.

        public static final Events DATA_INTEG_SERVICE_INTERRUPTED
        Data integrity service thread interrupted. This is non-fatal and indicates that the bookie is shutting down. The full check will resume once the bookie is started again.

        public static final Events DATA_INTEG_SERVICE_ERROR
        An error occurred in the in the data integrity service loop. This normally indicates that an error occurred in the full check. The full check will be tried again. It could also indicate an error checking the NEEDS_INTEGRITY_CHECK flag, which indicates disk issues.
      • MARK_LIMBO

        public static final Events MARK_LIMBO
        Mark a ledger as in-limbo. In limbo ledgers are ledgers for whose entries we cannot safely answer queries positively or negatively. These are ledgers which have not been closed and where this bookie appears in the final ensemble. We may have had an entry in the past, but due to disk failures or configuration changes it may not currently exist locally. However, we cannot tell clients that the entry doesn't exist, because the client would understand that to mean that it never existed, and this would break consistency in the ledger recovery protocol. For limbo ledgers, all entry level queries should throw an exception. We also mark the ledger as fenced at this point, as it may have been set on this ledger previously. This means no more writes for this ledger can come to this bookie.

        public static final Events LIMBO_OR_FENCE_ERROR
        An error occurred marking the ledger as fenced or as in-limbo. The most likely cause is a bad disk. This is a fatal error, as we cannot safely serve entries if we cannot set limbo and fence flags.

        public static final Events PREBOOT_START
        Start the preboot check. The preboot check runs when some configuration has changed regarding the disk configuration. This may be simply a disk being added, or it could be the disks being wiped. The preboot check needs to check which ledgers we are supposed to store according to ledger metadata. Any unclosed ledgers which contain this bookie in its last ensemble must be marked as in-limbo, as we don't know if entries from that ledger have previously existed on this bookie. The preboot check doesn't copy any data. That is left up to the full check which can run in the background while the bookie is serving data for non-limbo ledgers. The preboot check has a runId associated which can be used to pull together all the events from the same run. The preboot check will set the NEEDS_INTEGRITY_CHECK flag on storage to trigger a full check after the bookie has booted.

        public static final Events PREBOOT_END
        The preboot check has completed successfully. The event contains the number of ledgers that have been processed.

        public static final Events PREBOOT_ERROR
        An error occurred during the preboot check. This is a fatal error as we cannot safely serve data if the correct ledgers have not been marked as in-limbo. The error could be due to problems accessing the metadata store, or due to disk issues.

        public static final Events INVALID_METADATA
        Preboot found an invalid ledger metadata. All ledger metadata must have at least one ensemble but the process found one with none.

        public static final Events ENSURE_LEDGER_ERROR
        Preboot must create a ledger that the bookie does not have but that metadata says the bookie should have. This can happen due to things like ensemble changes and when a ledger is closed. If the ledger cannot be created on the bookie then this error will cause preboot to fail.

        public static final Events FULL_CHECK_INIT
        Initialized the full check. If we have cached metadata from a previous run, or the preboot check, then we use that. Otherwise we read the metadata from the metadata store. The full check goes through each ledger for which this bookie is supposed to store entries and checks that these entries exist on the bookie. If they do not exist, they are copied from another bookie. Each full check has a runId associated which can be used to find all events from the check.

        public static final Events FULL_CHECK_COMPLETE
        The full check has completed.

        public static final Events FULL_CHECK_START
        Start iterating through the ledger that should be on this bookie. The event is annotated with the number of ledgers which will be checked, which may be fewer that the total number of ledgers on the bookie as a previous run may have verified that some ledgers are ok and don't need to be checked.

        public static final Events FULL_CHECK_END
        The full check has completed. This can be an info event or an error event. The event is annotated with the number of ledgers which were checked and found to be ok, the number that were found to be missing and the number for which errors occurred during the check. The missing ledgers have been deleted on the cluster, so don't need to be processed again. If there is a non-zero of ledgers with errors, the whole event is an error. An error for this event is non-fatal. Any ledgers which finished with error will be processed again the next time the full check runs. The full check continues retrying until there are no errors.

        public static final Events FULL_CHECK_ERROR
        An error occurred during the full check, but not while processing ledgers. This error could occur while flushing the ledger storage or clearing the full check flag.

        public static final Events USE_CACHED_METADATA
        The full check will use cached metadata.

        public static final Events REFRESH_METADATA
        The full check will read the metadata from the metadata store.

        public static final Events CLEAR_INTEGCHECK_FLAG
        The NEEDS_INTEGRITY_CHECK will be cleared from the ledger storage. This signifies that the ledger storage contains everything it should and the full check does not need to be retried, even after reboot.

        public static final Events CLEAR_LIMBO_ERROR
        An error occurred while clearing the limbo flag for a ledger. This is generally a disk error. This error is non-fatal and the operation will be tried again on the next full check.

        public static final Events RECOVER_LIMBO_LEDGER
        Recover a ledger that has been marked as in limbo. This runs the ledger recovery algorithm to find the last entry of the ledger and mark the ledger as closed. As the ledger is marked as in-limbo locally, the current bookie not take part in the recovery process apart from initializing it. Once recovery completes successfully, the limbo flag can be cleared for the ledger.

        public static final Events RECOVER_LIMBO_LEDGER_MISSING
        The ledger has been deleted from the ledger metadata store, so we don't need to continue any processing on it.

        public static final Events RECOVER_LIMBO_LEDGER_ERROR
        An error occurred during recovery. This could be due to not having enough bookies available to recover the ledger. The error is non-fatal. The recovery will be tried again on the next run of ledger recovery.

        public static final Events RECOVER_LIMBO_LEDGER_CLOSE_ERROR
        An error occurred when trying to close the ledger handle of a recovered ledger. This shouldn't happen, as closing a recovered ledger should not involve any I/O. This error is non-fatal and the event is registered for informational purposes only.

        public static final Events LEDGER_CHECK_AND_COPY_START
        Start checking whether the entries for a ledger exist locally, and copying them if they do not.

        public static final Events LEDGER_CHECK_AND_COPY_END
        Checking and copying has completed for a ledger. If any entry failed to copy this is a warning event. The ledger will be retried on the next run of the full check. This event is annotated with the number of entries copied, the number of errors and the total number of bytes copied for the ledger.
    • Method Detail

      • values

        public static Events[] values()
        Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:
        for (Events c : Events.values())
        an array containing the constants of this enum type, in the order they are declared
      • valueOf

        public static Events valueOf​(java.lang.String name)
        Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)
        name - the name of the enum constant to be returned.
        the enum constant with the specified name
        java.lang.IllegalArgumentException - if this enum type has no constant with the specified name
        java.lang.NullPointerException - if the argument is null