recovery_unit.h

Go to the documentation of this file.

#pragma once

#include <cstdint>
#include <stdlib.h>
#include <string>

#include "mongo/base/disallow_copying.h"
#include "mongo/base/status.h"
#include "mongo/bson/timestamp.h"
#include "mongo/db/repl/read_concern_level.h"
#include "mongo/db/repl/replication_coordinator.h"
#include "mongo/db/storage/snapshot.h"

namespace mongo {

class BSONObjBuilder;
class OperationContext;

class RecoveryUnit {
    MONGO_DISALLOW_COPYING(RecoveryUnit);

public:
    virtual ~RecoveryUnit() {}

    virtual void beginUnitOfWork(OperationContext* opCtx) = 0;

    virtual void commitUnitOfWork() = 0;

    virtual void abortUnitOfWork() = 0;

    virtual void prepareUnitOfWork() {
        uasserted(ErrorCodes::CommandNotSupported,
                  "This storage engine does not support prepared transactions");
    }


    virtual void setIgnorePrepared(bool ignore) {}

    virtual bool waitUntilDurable() = 0;

    virtual bool waitUntilUnjournaledWritesDurable() {
        return waitUntilDurable();
    }

    virtual void abandonSnapshot() = 0;

    virtual void preallocateSnapshot() {}

    virtual Status obtainMajorityCommittedSnapshot() {
        return {ErrorCodes::CommandNotSupported,
                "Current storage engine does not support majority readConcerns"};
    }

    virtual boost::optional<Timestamp> getPointInTimeReadTimestamp() const {
        return boost::none;
    }

    virtual SnapshotId getSnapshotId() const = 0;

    virtual Status setTimestamp(Timestamp timestamp) {
        return Status::OK();
    }

    virtual void setCommitTimestamp(Timestamp timestamp) {}

    virtual void clearCommitTimestamp() {}

    virtual Timestamp getCommitTimestamp() {
        return {};
    }

    virtual void setPrepareTimestamp(Timestamp timestamp) {
        uasserted(ErrorCodes::CommandNotSupported,
                  "This storage engine does not support prepared transactions");
    }

    enum ReadSource {
        kUnset,
        kNoTimestamp,
        kMajorityCommitted,
        kLastApplied,
        kLastAppliedSnapshot,
        kProvided
    };

    virtual void setTimestampReadSource(ReadSource source,
                                        boost::optional<Timestamp> provided = boost::none) {}

    virtual ReadSource getTimestampReadSource() const {
        return ReadSource::kUnset;
    };

    class Change {
    public:
        virtual ~Change() {}

        virtual void rollback() = 0;
        virtual void commit(boost::optional<Timestamp> commitTime) = 0;
    };

    virtual void registerChange(Change* change) = 0;

    template <typename Callback>
    void onRollback(Callback callback) {
        class OnRollbackChange final : public Change {
        public:
            OnRollbackChange(Callback&& callback) : _callback(std::move(callback)) {}
            void rollback() final {
                _callback();
            }
            void commit(boost::optional<Timestamp>) final {}

        private:
            Callback _callback;
        };

        registerChange(new OnRollbackChange(std::move(callback)));
    }

    template <typename Callback>
    void onCommit(Callback callback) {
        class OnCommitChange final : public Change {
        public:
            OnCommitChange(Callback&& callback) : _callback(std::move(callback)) {}
            void rollback() final {}
            void commit(boost::optional<Timestamp> commitTime) final {
                _callback(commitTime);
            }

        private:
            Callback _callback;
        };

        registerChange(new OnCommitChange(std::move(callback)));
    }

    //
    // The remaining methods probably belong on DurRecoveryUnit rather than on the interface.
    //

    virtual void* writingPtr(void* data, size_t len) = 0;

    //
    // Syntactic sugar
    //

    inline int& writingInt(int& d) {
        return *writing(&d);
    }

    template <typename T>
    inline T* writing(T* x) {
        writingPtr(x, sizeof(T));
        return x;
    }

    virtual void setRollbackWritesDisabled() = 0;

    virtual void setOrderedCommit(bool orderedCommit) = 0;

protected:
    RecoveryUnit() {}
};

}  // namespace mongo