Finalize Cutover Process

Verify the status of mongosync.

Call the progress endpoint to determine the status of mongosync before starting the cutover process. Ensure that the mongosync process status indicates the following values:

• canCommit is true.

• lagTimeSeconds is small (near 0).

  If lagTimeSeconds isn't close to 0 when the cutover starts, cutover might take a long time.

• When using the Embedded Verifier check both the verification.source and the verification.destination return documents. The lagTimeSeconds fields in both documents should be near 0 and the phase fields should show "stream hashing".

  If /commit is called and the values are not near 0 or if the verifier is not in the stream hashing phase, the cutover process might take a long a time.

The following example returns the status of the synchronization process.

curl localhost:27182/api/v1/progress -XGET

{
   "progress":
      {
         "state":"RUNNING",
         "canCommit":true,
         "canWrite":false,
         "info":"change event application",
         "lagTimeSeconds":0,
         "collectionCopy":
            {
               "estimatedTotalBytes":694,
               "estimatedCopiedBytes":694
            },
         "directionMapping":
            {
               "Source":"cluster0: localhost:27017",
               "Destination":"cluster1: localhost:27018"
            },
         "verification":
            {
               "source":
                  {
                     "estimatedDocumentCount": 42,
                     "hashedDocumentCount": 42,
                     "lagTimeSeconds": 2,
                     "totalCollectionCount": 42,
                     "scannedCollectionCount": 10,
                     "phase": "stream hashing"
                  },
               "destination": {
                     "estimatedDocumentCount": 42,
                     "hashedDocumentCount": 42,
                     "lagTimeSeconds": 2,
                     "totalCollectionCount": 42,
                     "scannedCollectionCount": 10,
                     "phase": "stream hashing"
               }
            }
      },
   "success": true
}

Stop any write operations to the synced collections on the source.

• If you start mongosync with enableUserWriteBlocking set to true, mongosync blocks all write operations on the entire source cluster during the commit (step 4) for you.

• If you didn't start mongosync with enableUserWriteBlocking, ensure that you disable writes. For example, run the setUserWriteBlockMode command on the source cluster:

  db.adminCommand( {
      setUserWriteBlockMode: 1,
      global: true
  } )

• If mongosync uses filtered sync, it's not necessary to disable writes to the entire source cluster. However, you must ensure that you stop write operations for the collections that the filter includes.

Send a commit request to mongosync.

If you start multiple mongosync instances for your migration, you must issue a commit request for each mongosync instance.

curl localhost:27182/api/v1/commit -XPOST --data '{ }'

{"success":true}

Wait until you can perform writes on the destination cluster.

Call the progress endpoint to determine if canWrite is true. If canWrite is false, wait until progress shows canWrite is true.

curl -sS localhost:27182/api/v1/progress -XGET | jq ".progress.canWrite"

true

Verify data transfer.

Verify the successful sync of data from the source to the destination cluster.

For more information, see Verify Data Transfer.

Enable application writes on the destination cluster.

To enable writes, update setUserWriteBlockMode:

db.adminCommand(
   {
      setUserWriteBlockMode: 1,
      global: false
   }
)

Then, transfer your application workload to the destination cluster.

Call the progress endpoint to determine the status of the mongosync process.

When the mongosync progress response indicates that the mongosync state is COMMITTED, the cutover process is complete.

curl -sS localhost:27182/api/v1/progress -XGET | jq ".progress.state"

"COMMITTED"