storage_engine.h

Go to the documentation of this file.

// storage_engine.h

#pragma once

#include <string>
#include <vector>

#include "mongo/base/status.h"
#include "mongo/bson/bsonobj.h"
#include "mongo/bson/timestamp.h"
#include "mongo/util/mongoutils/str.h"

namespace mongo {

class DatabaseCatalogEntry;
class JournalListener;
class OperationContext;
class RecoveryUnit;
class SnapshotManager;
struct StorageGlobalParams;
class StorageEngineLockFile;
class StorageEngineMetadata;

class StorageEngine {
public:
    class Factory {
    public:
        virtual ~Factory() {}

        virtual StorageEngine* create(const StorageGlobalParams& params,
                                      const StorageEngineLockFile* lockFile) const = 0;

        virtual StringData getCanonicalName() const = 0;

        virtual Status validateCollectionStorageOptions(const BSONObj& options) const {
            if (options.isEmpty())
                return Status::OK();
            return Status(ErrorCodes::InvalidOptions,
                          str::stream() << "storage engine " << getCanonicalName()
                                        << " does not support any collection storage options");
        }

        virtual Status validateIndexStorageOptions(const BSONObj& options) const {
            if (options.isEmpty())
                return Status::OK();
            return Status(ErrorCodes::InvalidOptions,
                          str::stream() << "storage engine " << getCanonicalName()
                                        << " does not support any index storage options");
        }

        virtual Status validateMetadata(const StorageEngineMetadata& metadata,
                                        const StorageGlobalParams& params) const = 0;

        virtual BSONObj createMetadataOptions(const StorageGlobalParams& params) const = 0;

        virtual bool supportsReadOnly() const {
            return false;
        }
    };

    virtual ~StorageEngine() {}

    virtual void finishInit() {}

    virtual RecoveryUnit* newRecoveryUnit() = 0;

    virtual void listDatabases(std::vector<std::string>* out) const = 0;

    virtual DatabaseCatalogEntry* getDatabaseCatalogEntry(OperationContext* opCtx,
                                                          StringData db) = 0;

    virtual bool supportsDocLocking() const = 0;

    virtual bool supportsDBLocking() const {
        return true;
    }

    virtual bool supportsCappedCollections() const {
        return true;
    }

    virtual bool isDurable() const = 0;

    virtual bool isEphemeral() const = 0;

    virtual bool isMmapV1() const {
        return false;
    }

    virtual void loadCatalog(OperationContext* opCtx) {}
    virtual void closeCatalog(OperationContext* opCtx) {}

    virtual Status closeDatabase(OperationContext* opCtx, StringData db) = 0;

    virtual Status dropDatabase(OperationContext* opCtx, StringData db) = 0;

    virtual int flushAllFiles(OperationContext* opCtx, bool sync) = 0;

    virtual Status beginBackup(OperationContext* opCtx) {
        return Status(ErrorCodes::CommandNotSupported,
                      "The current storage engine doesn't support backup mode");
    }

    virtual void endBackup(OperationContext* opCtx) {
        return;
    }

    virtual Status repairRecordStore(OperationContext* opCtx, const std::string& ns) = 0;

    virtual void cleanShutdown() = 0;

    virtual SnapshotManager* getSnapshotManager() const {
        return nullptr;
    }

    virtual void setJournalListener(JournalListener* jl) = 0;

    virtual bool supportsRecoverToStableTimestamp() const {
        return false;
    }

    virtual bool supportsReadConcernSnapshot() const {
        return false;
    }

    virtual StatusWith<Timestamp> recoverToStableTimestamp(OperationContext* opCtx) {
        fassertFailed(40547);
    }

    virtual boost::optional<Timestamp> getRecoveryTimestamp() const {
        MONGO_UNREACHABLE;
    }

    virtual boost::optional<Timestamp> getLastStableCheckpointTimestamp() const {
        MONGO_UNREACHABLE;
    }

    virtual void setStableTimestamp(Timestamp timestamp) {}

    virtual void setInitialDataTimestamp(Timestamp timestamp) {}

    virtual void setOldestTimestampFromStable() {}

    virtual void setOldestTimestamp(Timestamp timestamp) {}

    virtual bool isCacheUnderPressure(OperationContext* opCtx) const {
        return false;
    }

    virtual void setCachePressureForTest(int pressure) {}

    virtual void replicationBatchIsComplete() const {};

    // (CollectionName, IndexName)
    typedef std::pair<std::string, std::string> CollectionIndexNamePair;

    virtual StatusWith<std::vector<CollectionIndexNamePair>> reconcileCatalogAndIdents(
        OperationContext* opCtx) {
        return std::vector<CollectionIndexNamePair>();
    };

    virtual Timestamp getAllCommittedTimestamp() const = 0;
};

}  // namespace mongo