dur_recover.h

Go to the documentation of this file.

// @file dur.h durability support

#pragma once

#include <boost/filesystem/operations.hpp>
#include <list>
#include <memory>

#include "mongo/db/service_context.h"
#include "mongo/db/storage/mmap_v1/dur_journalformat.h"
#include "mongo/stdx/mutex.h"
#include "mongo/util/concurrency/mutex.h"

namespace mongo {

class DurableMappedFile;

namespace dur {

struct ParsedJournalEntry;

class RecoveryJob {
    MONGO_DISALLOW_COPYING(RecoveryJob);

public:
    RecoveryJob();
    ~RecoveryJob();

    void go(OperationContext* opCtx, std::vector<boost::filesystem::path>& files);

    void processSection(OperationContext* opCtx,
                        const JSectHeader* h,
                        const void* data,
                        unsigned len,
                        const JSectFooter* f);

    // locks and calls _close()
    void close(OperationContext* opCtx);

    static RecoveryJob& get() {
        return _instance;
    }

private:
    class Last {
    public:
        Last(OperationContext* opCtx);

        DurableMappedFile* newEntry(const ParsedJournalEntry&, RecoveryJob&);

        OperationContext* opCtx() {
            return _opCtx;
        }

    private:
        OperationContext* _opCtx;
        DurableMappedFile* mmf;
        std::string dbName;
        int fileNo;
    };


    void write(Last& last, const ParsedJournalEntry& entry);  // actually writes to the file
    void applyEntry(Last& last, const ParsedJournalEntry& entry, bool apply, bool dump);
    void applyEntries(OperationContext* opCtx, const std::vector<ParsedJournalEntry>& entries);
    bool processFileBuffer(OperationContext* opCtx, const void*, unsigned len);
    bool processFile(OperationContext* opCtx, boost::filesystem::path journalfile);
    void _close(OperationContext* opCtx);  // doesn't lock

    // Set of memory mapped files and a mutex to protect them
    stdx::mutex _mx;
    std::list<std::shared_ptr<DurableMappedFile>> _mmfs;

    // Are we in recovery or WRITETODATAFILES
    bool _recovering;

    unsigned long long _lastDataSyncedFromLastRun;
    unsigned long long _lastSeqSkipped;
    bool _appliedAnySections;


    static RecoveryJob& _instance;
};


void replayJournalFilesAtStartup();
}
}