mongo 2.20.0 → 2.21.0

data/spec/spec_tests/data/client_side_operations_timeout/gridfs-upload.yml

@@ -0,0 +1,249 @@
+description: "timeoutMS behaves correctly for GridFS upload operations"
+
+schemaVersion: "1.9"
+
+runOnRequirements:
+  - minServerVersion: "4.4"
+    serverless: forbid  # GridFS ops can be slow on serverless.
+
+createEntities:
+  - client:
+      id: &failPointClient failPointClient
+      useMultipleMongoses: false
+  - client:
+      id: &client client
+      uriOptions:
+        timeoutMS: 75
+      useMultipleMongoses: false
+  - database:
+      id: &database database
+      client: *client
+      databaseName: &databaseName test
+  - bucket:
+      id: &bucket bucket
+      database: *database
+  - collection:
+      id: &filesCollection filesCollection
+      database: *database
+      collectionName: &filesCollectionName fs.files
+  - collection:
+      id: &chunksCollection chunksCollection
+      database: *database
+      collectionName: &chunksCollectionName fs.chunks
+
+initialData:
+  - collectionName: *filesCollectionName
+    databaseName: *databaseName
+    documents: []
+  - collectionName: *chunksCollectionName
+    databaseName: *databaseName
+    documents: []
+
+tests:
+  # Many tests in this file do not specify command monitoring expectations because GridFS uploads internally do a
+  # number of operations, so expecting an exact set of commands can cause flaky failures.
+
+  - description: "timeoutMS can be overridden for upload"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 1 }
+            data:
+              failCommands: ["find"]
+              blockConnection: true
+              blockTimeMS: 100
+      - name: upload
+        object: *bucket
+        arguments:
+          filename: filename
+          source: { $$hexBytes: "1122334455" }
+          timeoutMS: 1000
+
+  # On the first write to the bucket, drivers check if the files collection is empty to see if indexes need to be
+  # created.
+  - description: "timeoutMS applied to initial find on files collection"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:  
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 1 }
+            data:
+              failCommands: ["find"]
+              blockConnection: true
+              blockTimeMS: 100
+      - name: upload
+        object: *bucket
+        arguments:
+          filename: filename
+          source: { $$hexBytes: "1122334455" }
+        expectError:
+          isTimeoutError: true
+
+  # On the first write to the bucket, drivers check if the files collection has the correct indexes.
+  - description: "timeoutMS applied to listIndexes on files collection"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:  
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 1 }
+            data:
+              failCommands: ["listIndexes"]
+              blockConnection: true
+              blockTimeMS: 100
+      - name: upload
+        object: *bucket
+        arguments:
+          filename: filename
+          source: { $$hexBytes: "1122334455" }
+        expectError:
+          isTimeoutError: true
+
+  # If the files collection is empty when the first write to the bucket occurs, drivers attempt to create an index
+  # on the bucket's files collection.
+  - description: "timeoutMS applied to index creation for files collection"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:  
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 1 }
+            data:
+              failCommands: ["createIndexes"]
+              blockConnection: true
+              blockTimeMS: 100
+      - name: upload
+        object: *bucket
+        arguments:
+          filename: filename
+          source: { $$hexBytes: "1122334455" }
+        expectError:
+          isTimeoutError: true
+
+  # On the first write to the bucket, drivers check if the chunks collection has the correct indexes.
+  - description: "timeoutMS applied to listIndexes on chunks collection"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:  
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            # The first listIndexes will be on the files collection, so we skip it.
+            mode: { skip: 1 }
+            data:
+              failCommands: ["listIndexes"]
+              blockConnection: true
+              blockTimeMS: 100
+      - name: upload
+        object: *bucket
+        arguments:
+          filename: filename
+          source: { $$hexBytes: "1122334455" }
+        expectError:
+          isTimeoutError: true
+
+  # If the files collection is empty when the first write to the bucket occurs, drivers attempt to create an index
+  # on the bucket's chunks collection.
+  - description: "timeoutMS applied to index creation for chunks collection"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:  
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            # This index is created after the one on the files collection, so we skip the first createIndexes command
+            # and target the second.
+            mode: { skip: 1 }
+            data:
+              failCommands: ["createIndexes"]
+              blockConnection: true
+              blockTimeMS: 100
+      - name: upload
+        object: *bucket
+        arguments:
+          filename: filename
+          source: { $$hexBytes: "1122334455" }
+        expectError:
+          isTimeoutError: true
+
+  - description: "timeoutMS applied to chunk insertion"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:  
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 1 }
+            data:
+              failCommands: ["insert"]
+              blockConnection: true
+              blockTimeMS: 100
+      - name: upload
+        object: *bucket
+        arguments:
+          filename: filename
+          source: { $$hexBytes: "1122334455" }
+        expectError:
+          isTimeoutError: true
+
+  - description: "timeoutMS applied to creation of files document"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:  
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            # Skip the insert to upload the chunk. Because the whole file fits into one chunk, the second insert will
+            # be the files document upload.
+            mode: { skip: 1 }
+            data:
+              failCommands: ["insert"]
+              blockConnection: true
+              blockTimeMS: 100
+      - name: upload
+        object: *bucket
+        arguments:
+          filename: filename
+          source: { $$hexBytes: "1122334455" }
+        expectError:
+          isTimeoutError: true
+
+  # Test that drivers apply timeoutMS to the entire upload rather than refreshing it between individual commands. We
+  # test this by blocking the "find" and "listIndexes" commands for 50ms each and performing an upload. The upload
+  # should inherit timeoutMS=75 from the client/database and the server takes over 75ms total, so the operation should
+  # fail.
+  - description: "timeoutMS applied to upload as a whole, not individual parts"
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 2 }
+            data:
+              failCommands: ["find", "listIndexes"]
+              blockConnection: true
+              blockTimeMS: 50
+      - name: upload
+        object: *bucket
+        arguments:
+          filename: filename
+          source: { $$hexBytes: "1122334455" }
+        expectError:
+          isTimeoutError: true

data/spec/spec_tests/data/client_side_operations_timeout/legacy-timeouts.yml

@@ -0,0 +1,204 @@
+description: "legacy timeouts continue to work if timeoutMS is not set"
+
+schemaVersion: "1.0"
+
+runOnRequirements:
+  - minServerVersion: "4.4"
+
+initialData:
+  - collectionName: &collectionName coll
+    databaseName: &databaseName test
+    documents: []
+
+tests:
+  - description: "socketTimeoutMS is not used to derive a maxTimeMS command field"
+    operations:
+      - name: createEntities
+        object: testRunner
+        arguments:
+          entities:
+            - client:
+                id: &client client
+                observeEvents:
+                  - commandStartedEvent
+                uriOptions:
+                  socketTimeoutMS: 50000
+            - database:
+                id: &database database
+                client: *client
+                databaseName: *databaseName
+            - collection:
+                id: &collection collection
+                database: *database
+                collectionName: *collectionName
+      - name: insertOne
+        object: *collection
+        arguments:
+          document: { x: 1 }
+    expectEvents:
+      - client: *client
+        events:
+          - commandStartedEvent:
+              commandName: insert
+              databaseName: *databaseName
+              command:
+                insert: *collectionName
+                maxTimeMS: { $$exists: false }
+
+  - description: "waitQueueTimeoutMS is not used to derive a maxTimeMS command field"
+    operations:
+      - name: createEntities
+        object: testRunner
+        arguments:
+          entities:
+            - client:
+                id: &client client
+                observeEvents:
+                  - commandStartedEvent
+                uriOptions:
+                  waitQueueTimeoutMS: 50000
+            - database:
+                id: &database database
+                client: *client
+                databaseName: *databaseName
+            - collection:
+                id: &collection collection
+                database: *database
+                collectionName: *collectionName
+      - name: insertOne
+        object: *collection
+        arguments:
+          document: { x: 1 }
+    expectEvents:
+      - client: *client
+        events:
+          - commandStartedEvent:
+              commandName: insert
+              databaseName: *databaseName
+              command:
+                insert: *collectionName
+                maxTimeMS: { $$exists: false }
+
+  - description: "wTimeoutMS is not used to derive a maxTimeMS command field"
+    operations:
+      - name: createEntities
+        object: testRunner
+        arguments:
+          entities:
+            - client:
+                id: &client client
+                observeEvents:
+                  - commandStartedEvent
+                uriOptions:
+                  wTimeoutMS: &wTimeoutMS 50000
+            - database:
+                id: &database database
+                client: *client
+                databaseName: *databaseName
+            - collection:
+                id: &collection collection
+                database: *database
+                collectionName: *collectionName
+      - name: insertOne
+        object: *collection
+        arguments:
+          document: { x: 1 }
+    expectEvents:
+      - client: *client
+        events:
+          - commandStartedEvent:
+              commandName: insert
+              databaseName: *databaseName
+              command:
+                insert: *collectionName
+                maxTimeMS: { $$exists: false }
+                writeConcern:
+                  wtimeout: *wTimeoutMS
+
+  # If the maxTimeMS option is set for a specific command, it should be used as the maxTimeMS command field without any
+  # modifications. This is different from timeoutMS because in that case, drivers subtract the target server's min
+  # RTT from the remaining timeout to derive a maxTimeMS field.
+  - description: "maxTimeMS option is used directly as the maxTimeMS field on a command"
+    operations:
+      - name: createEntities
+        object: testRunner
+        arguments:
+          entities:
+            - client:
+                id: &client client
+                observeEvents:
+                  - commandStartedEvent
+            - database:
+                id: &database database
+                client: *client
+                databaseName: *databaseName
+            - collection:
+                id: &collection collection
+                database: *database
+                collectionName: *collectionName
+      - name: estimatedDocumentCount
+        object: *collection
+        arguments:
+          maxTimeMS: &maxTimeMS 50000
+    expectEvents:
+      - client: *client
+        events:
+          - commandStartedEvent:
+              commandName: count
+              databaseName: *databaseName
+              command:
+                count: *collectionName
+                maxTimeMS: *maxTimeMS
+
+  # Same test as above but with the maxCommitTimeMS option.
+  - description: "maxCommitTimeMS option is used directly as the maxTimeMS field on a commitTransaction command"
+    runOnRequirements:
+      # Note: minServerVersion is specified in top-level runOnRequirements
+      - topologies: ["replicaset", "sharded"]
+    operations:
+      - name: createEntities
+        object: testRunner
+        arguments:
+          entities:
+            - client:
+                id: &client client
+                observeEvents:
+                  - commandStartedEvent
+            - database:
+                id: &database database
+                client: *client
+                databaseName: *databaseName
+            - collection:
+                id: &collection collection
+                database: *database
+                collectionName: *collectionName
+            - session:
+                id: &session session
+                client: *client
+                sessionOptions:
+                  defaultTransactionOptions:
+                    maxCommitTimeMS: &maxCommitTimeMS 1000
+      - name: startTransaction
+        object: *session
+      - name: insertOne
+        object: *collection
+        arguments:
+          document: { _id: 1 }
+          session: *session
+      - name: commitTransaction
+        object: *session
+    expectEvents:
+      - client: *client
+        events:
+          - commandStartedEvent:
+              commandName: insert
+              databaseName: *databaseName
+              command:
+                insert: *collectionName
+                maxTimeMS: { $$exists: false }
+          - commandStartedEvent:
+              commandName: commitTransaction
+              databaseName: admin
+              command:
+                commitTransaction: 1
+                maxTimeMS: *maxCommitTimeMS