1 files changed, 109 insertions, 111 deletions

diff --git a/src/mongo/db/repl/bgsync.h b/src/mongo/db/repl/bgsync.h
index d1e7e7ea692..8fe0c9e2b02 100644
--- a/src/mongo/db/repl/bgsync.h
+++ b/src/mongo/db/repl/bgsync.h
@@ -37,158 +37,156 @@
 
 namespace mongo {
 
-    class OperationContext;
+class OperationContext;
 
 namespace repl {
 
-    class Member;
-    class ReplicationCoordinator;
+class Member;
+class ReplicationCoordinator;
 
-    // This interface exists to facilitate easier testing;
-    // the test infrastructure implements these functions with stubs.
-    class BackgroundSyncInterface {
-    public:
-        virtual ~BackgroundSyncInterface();
+// This interface exists to facilitate easier testing;
+// the test infrastructure implements these functions with stubs.
+class BackgroundSyncInterface {
+public:
+    virtual ~BackgroundSyncInterface();
 
-        // Gets the head of the buffer, but does not remove it.
-        // Returns true if an element was present at the head;
-        // false if the queue was empty.
-        virtual bool peek(BSONObj* op) = 0;
+    // Gets the head of the buffer, but does not remove it.
+    // Returns true if an element was present at the head;
+    // false if the queue was empty.
+    virtual bool peek(BSONObj* op) = 0;
 
-        // Deletes objects in the queue;
-        // called by sync thread after it has applied an op
-        virtual void consume() = 0;
+    // Deletes objects in the queue;
+    // called by sync thread after it has applied an op
+    virtual void consume() = 0;
 
-        // wait up to 1 second for more ops to appear
-        virtual void waitForMore() = 0;
-    };
+    // wait up to 1 second for more ops to appear
+    virtual void waitForMore() = 0;
+};
 
 
-    /**
-     * Lock order:
-     * 1. rslock
-     * 2. rwlock
-     * 3. BackgroundSync::_mutex
-     */
-    class BackgroundSync : public BackgroundSyncInterface {
-    public:
-        // Allow index prefetching to be turned on/off
-        enum IndexPrefetchConfig {
-            PREFETCH_NONE=0, PREFETCH_ID_ONLY=1, PREFETCH_ALL=2
-        };
+/**
+ * Lock order:
+ * 1. rslock
+ * 2. rwlock
+ * 3. BackgroundSync::_mutex
+ */
+class BackgroundSync : public BackgroundSyncInterface {
+public:
+    // Allow index prefetching to be turned on/off
+    enum IndexPrefetchConfig { PREFETCH_NONE = 0, PREFETCH_ID_ONLY = 1, PREFETCH_ALL = 2 };
 
-        static BackgroundSync* get();
+    static BackgroundSync* get();
 
-        // stop syncing (when this node becomes a primary, e.g.)
-        void stop();
+    // stop syncing (when this node becomes a primary, e.g.)
+    void stop();
 
 
-        void shutdown();
-        void notify(OperationContext* txn);
+    void shutdown();
+    void notify(OperationContext* txn);
 
-        // Blocks until _pause becomes true from a call to stop() or shutdown()
-        void waitUntilPaused();
+    // Blocks until _pause becomes true from a call to stop() or shutdown()
+    void waitUntilPaused();
 
-        virtual ~BackgroundSync() {}
+    virtual ~BackgroundSync() {}
 
-        // starts the producer thread
-        void producerThread();
-        // starts the sync target notifying thread
-        void notifierThread();
+    // starts the producer thread
+    void producerThread();
+    // starts the sync target notifying thread
+    void notifierThread();
 
-        HostAndPort getSyncTarget();
+    HostAndPort getSyncTarget();
 
-        // Interface implementation
+    // Interface implementation
 
-        virtual bool peek(BSONObj* op);
-        virtual void consume();
-        virtual void clearSyncTarget();
-        virtual void waitForMore();
+    virtual bool peek(BSONObj* op);
+    virtual void consume();
+    virtual void clearSyncTarget();
+    virtual void waitForMore();
 
-        // For monitoring
-        BSONObj getCounters();
+    // For monitoring
+    BSONObj getCounters();
 
-        long long getLastAppliedHash() const;
-        void setLastAppliedHash(long long oldH);
-        void loadLastAppliedHash(OperationContext* txn);
+    long long getLastAppliedHash() const;
+    void setLastAppliedHash(long long oldH);
+    void loadLastAppliedHash(OperationContext* txn);
 
-        // Clears any fetched and buffered oplog entries.
-        void clearBuffer();
+    // Clears any fetched and buffered oplog entries.
+    void clearBuffer();
 
-        bool getInitialSyncRequestedFlag();
-        void setInitialSyncRequestedFlag(bool value);
+    bool getInitialSyncRequestedFlag();
+    void setInitialSyncRequestedFlag(bool value);
 
-        void setIndexPrefetchConfig(const IndexPrefetchConfig cfg) {
-            _indexPrefetchConfig = cfg;
-        }
+    void setIndexPrefetchConfig(const IndexPrefetchConfig cfg) {
+        _indexPrefetchConfig = cfg;
+    }
 
-        IndexPrefetchConfig getIndexPrefetchConfig() {
-            return _indexPrefetchConfig;
-        }
+    IndexPrefetchConfig getIndexPrefetchConfig() {
+        return _indexPrefetchConfig;
+    }
 
 
-        // Testing related stuff
-        void pushTestOpToBuffer(const BSONObj& op);
-    private:
-        static BackgroundSync *s_instance;
-        // protects creation of s_instance
-        static stdx::mutex s_mutex;
+    // Testing related stuff
+    void pushTestOpToBuffer(const BSONObj& op);
 
-        // Production thread
-        BlockingQueue<BSONObj> _buffer;
-        OplogReader _syncSourceReader;
+private:
+    static BackgroundSync* s_instance;
+    // protects creation of s_instance
+    static stdx::mutex s_mutex;
 
-        // _mutex protects all of the class variables except _syncSourceReader and _buffer
-        mutable stdx::mutex _mutex;
+    // Production thread
+    BlockingQueue<BSONObj> _buffer;
+    OplogReader _syncSourceReader;
 
-        OpTime _lastOpTimeFetched;
+    // _mutex protects all of the class variables except _syncSourceReader and _buffer
+    mutable stdx::mutex _mutex;
 
-        // lastAppliedHash is used to generate a new hash for the following op, when primary.
-        long long _lastAppliedHash;
-        // lastFetchedHash is used to match ops to determine if we need to rollback, when
-        // a secondary.
-        long long _lastFetchedHash;
+    OpTime _lastOpTimeFetched;
 
-        // if produce thread should be running
-        bool _pause;
-        stdx::condition_variable _pausedCondition;
-        bool _appliedBuffer;
-        stdx::condition_variable _appliedBufferCondition;
+    // lastAppliedHash is used to generate a new hash for the following op, when primary.
+    long long _lastAppliedHash;
+    // lastFetchedHash is used to match ops to determine if we need to rollback, when
+    // a secondary.
+    long long _lastFetchedHash;
 
-        HostAndPort _syncSourceHost;
+    // if produce thread should be running
+    bool _pause;
+    stdx::condition_variable _pausedCondition;
+    bool _appliedBuffer;
+    stdx::condition_variable _appliedBufferCondition;
 
-        BackgroundSync();
-        BackgroundSync(const BackgroundSync& s);
-        BackgroundSync operator=(const BackgroundSync& s);
+    HostAndPort _syncSourceHost;
 
-        // Production thread
-        void _producerThread();
-        // Adds elements to the list, up to maxSize.
-        void produce(OperationContext* txn);
-        // Checks the criteria for rolling back and executes a rollback if warranted.
-        bool _rollbackIfNeeded(OperationContext* txn, OplogReader& r);
+    BackgroundSync();
+    BackgroundSync(const BackgroundSync& s);
+    BackgroundSync operator=(const BackgroundSync& s);
 
-        // Evaluate if the current sync target is still good
-        bool shouldChangeSyncSource();
+    // Production thread
+    void _producerThread();
+    // Adds elements to the list, up to maxSize.
+    void produce(OperationContext* txn);
+    // Checks the criteria for rolling back and executes a rollback if warranted.
+    bool _rollbackIfNeeded(OperationContext* txn, OplogReader& r);
 
-        // restart syncing
-        void start(OperationContext* txn);
+    // Evaluate if the current sync target is still good
+    bool shouldChangeSyncSource();
 
-        long long _readLastAppliedHash(OperationContext* txn);
+    // restart syncing
+    void start(OperationContext* txn);
 
-        // A pointer to the replication coordinator running the show.
-        ReplicationCoordinator* _replCoord;
+    long long _readLastAppliedHash(OperationContext* txn);
 
-        // bool for indicating resync need on this node and the mutex that protects it
-        // The resync command sets this flag; the Applier thread observes and clears it.
-        bool _initialSyncRequestedFlag;
-        stdx::mutex _initialSyncMutex;
+    // A pointer to the replication coordinator running the show.
+    ReplicationCoordinator* _replCoord;
 
-        // This setting affects the Applier prefetcher behavior.
-        IndexPrefetchConfig _indexPrefetchConfig;
+    // bool for indicating resync need on this node and the mutex that protects it
+    // The resync command sets this flag; the Applier thread observes and clears it.
+    bool _initialSyncRequestedFlag;
+    stdx::mutex _initialSyncMutex;
 
-    };
+    // This setting affects the Applier prefetcher behavior.
+    IndexPrefetchConfig _indexPrefetchConfig;
+};
 
 
-} // namespace repl
-} // namespace mongo
+}  // namespace repl
+}  // namespace mongo