mongodb
diff --git a/‎src/MongoDB.Driver/Core/Bindings/ChannelChannelSource.cs
Lines changed: 2 additions & 2 deletions b/‎src/MongoDB.Driver/Core/Bindings/ChannelChannelSource.cs
Lines changed: 2 additions & 2 deletions
diff --git a/‎src/MongoDB.Driver/Core/Bindings/ChannelReadBinding.cs
Lines changed: 6 additions & 6 deletions b/‎src/MongoDB.Driver/Core/Bindings/ChannelReadBinding.cs
Lines changed: 6 additions & 6 deletions
diff --git a/‎src/MongoDB.Driver/Core/Bindings/ChannelReadWriteBinding.cs
Lines changed: 20 additions & 20 deletions b/‎src/MongoDB.Driver/Core/Bindings/ChannelReadWriteBinding.cs
Lines changed: 20 additions & 20 deletions
diff --git a/‎src/MongoDB.Driver/Core/Bindings/ChannelSourceHandle.cs
Lines changed: 4 additions & 4 deletions b/‎src/MongoDB.Driver/Core/Bindings/ChannelSourceHandle.cs
Lines changed: 4 additions & 4 deletions
diff --git a/‎src/MongoDB.Driver/Core/Bindings/ChannelSourceReadWriteBinding.cs
Lines changed: 20 additions & 20 deletions b/‎src/MongoDB.Driver/Core/Bindings/ChannelSourceReadWriteBinding.cs
Lines changed: 20 additions & 20 deletions
diff --git a/‎src/MongoDB.Driver/Core/Bindings/CoreSession.cs
Lines changed: 8 additions & 8 deletions b/‎src/MongoDB.Driver/Core/Bindings/CoreSession.cs
Lines changed: 8 additions & 8 deletions
@@ -63,13 +63,13 @@ public void Dispose()
             }
         }
 
-        public IChannelHandle GetChannel(OperationCancellationContext cancellationContext)
+        public IChannelHandle GetChannel(OperationContext operationContext)
         {
             ThrowIfDisposed();
             return GetChannelHelper();
         }
 
-        public Task<IChannelHandle> GetChannelAsync(OperationCancellationContext cancellationContext)
+        public Task<IChannelHandle> GetChannelAsync(OperationContext operationContext)
         {
             ThrowIfDisposed();
             return Task.FromResult(GetChannelHelper());
 
@@ -57,26 +57,26 @@ public void Dispose()
             }
         }
 
-        public IChannelSourceHandle GetReadChannelSource(OperationCancellationContext cancellationContext)
+        public IChannelSourceHandle GetReadChannelSource(OperationContext operationContext)
         {
             ThrowIfDisposed();
             return GetReadChannelSourceHelper();
         }
 
-        public Task<IChannelSourceHandle> GetReadChannelSourceAsync(OperationCancellationContext cancellationContext)
+        public Task<IChannelSourceHandle> GetReadChannelSourceAsync(OperationContext operationContext)
         {
             ThrowIfDisposed();
             return Task.FromResult<IChannelSourceHandle>(GetReadChannelSourceHelper());
         }
 
-        public IChannelSourceHandle GetReadChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationCancellationContext cancellationContext)
+        public IChannelSourceHandle GetReadChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationContext operationContext)
         {
-            return GetReadChannelSource(cancellationContext);
+            return GetReadChannelSource(operationContext);
         }
 
-        public Task<IChannelSourceHandle> GetReadChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationCancellationContext cancellationContext)
+        public Task<IChannelSourceHandle> GetReadChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationContext operationContext)
         {
-            return GetReadChannelSourceAsync(cancellationContext);
+            return GetReadChannelSourceAsync(operationContext);
         }
 
         private IChannelSourceHandle GetReadChannelSourceHelper()
 
@@ -55,68 +55,68 @@ public void Dispose()
             }
         }
 
-        public IChannelSourceHandle GetReadChannelSource(OperationCancellationContext cancellationContext)
+        public IChannelSourceHandle GetReadChannelSource(OperationContext operationContext)
         {
             ThrowIfDisposed();
             return GetChannelSourceHelper();
         }
 
-        public Task<IChannelSourceHandle> GetReadChannelSourceAsync(OperationCancellationContext cancellationContext)
+        public Task<IChannelSourceHandle> GetReadChannelSourceAsync(OperationContext operationContext)
         {
             ThrowIfDisposed();
             return Task.FromResult(GetChannelSourceHelper());
         }
 
-        public IChannelSourceHandle GetReadChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationCancellationContext cancellationContext)
+        public IChannelSourceHandle GetReadChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationContext operationContext)
         {
-            return GetReadChannelSource(cancellationContext);
+            return GetReadChannelSource(operationContext);
         }
 
-        public Task<IChannelSourceHandle> GetReadChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationCancellationContext cancellationContext)
+        public Task<IChannelSourceHandle> GetReadChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationContext operationContext)
         {
-            return GetReadChannelSourceAsync(cancellationContext);
+            return GetReadChannelSourceAsync(operationContext);
         }
 
-        public IChannelSourceHandle GetWriteChannelSource(OperationCancellationContext cancellationContext)
+        public IChannelSourceHandle GetWriteChannelSource(OperationContext operationContext)
         {
             ThrowIfDisposed();
             return GetChannelSourceHelper();
         }
 
-        public IChannelSourceHandle GetWriteChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationCancellationContext cancellationContext)
+        public IChannelSourceHandle GetWriteChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationContext operationContext)
         {
-            return GetWriteChannelSource(cancellationContext);
+            return GetWriteChannelSource(operationContext);
         }
 
-        public IChannelSourceHandle GetWriteChannelSource(IMayUseSecondaryCriteria mayUseSecondary, OperationCancellationContext cancellationContext)
+        public IChannelSourceHandle GetWriteChannelSource(IMayUseSecondaryCriteria mayUseSecondary, OperationContext operationContext)
         {
-            return GetWriteChannelSource(cancellationContext); // ignore mayUseSecondary
+            return GetWriteChannelSource(operationContext); // ignore mayUseSecondary
         }
 
-        public IChannelSourceHandle GetWriteChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, IMayUseSecondaryCriteria mayUseSecondary, OperationCancellationContext cancellationContext)
+        public IChannelSourceHandle GetWriteChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, IMayUseSecondaryCriteria mayUseSecondary, OperationContext operationContext)
         {
-            return GetWriteChannelSource(mayUseSecondary, cancellationContext);
+            return GetWriteChannelSource(mayUseSecondary, operationContext);
         }
 
-        public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(OperationCancellationContext cancellationContext)
+        public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(OperationContext operationContext)
         {
             ThrowIfDisposed();
             return Task.FromResult(GetChannelSourceHelper());
         }
 
-        public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationCancellationContext cancellationContext)
+        public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationContext operationContext)
         {
-            return GetWriteChannelSourceAsync(cancellationContext);
+            return GetWriteChannelSourceAsync(operationContext);
         }
 
-        public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IMayUseSecondaryCriteria mayUseSecondary, OperationCancellationContext cancellationContext)
+        public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IMayUseSecondaryCriteria mayUseSecondary, OperationContext operationContext)
         {
-            return GetWriteChannelSourceAsync(cancellationContext); // ignore mayUseSecondary
+            return GetWriteChannelSourceAsync(operationContext); // ignore mayUseSecondary
         }
 
-        public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, IMayUseSecondaryCriteria mayUseSecondary, OperationCancellationContext cancellationContext)
+        public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, IMayUseSecondaryCriteria mayUseSecondary, OperationContext operationContext)
         {
-            return GetWriteChannelSourceAsync(mayUseSecondary, cancellationContext);
+            return GetWriteChannelSourceAsync(mayUseSecondary, operationContext);
         }
 
         private IChannelSourceHandle GetChannelSourceHelper()
 
@@ -54,16 +54,16 @@ public ICoreSessionHandle Session
         }
 
         // methods
-        public IChannelHandle GetChannel(OperationCancellationContext cancellationContext)
+        public IChannelHandle GetChannel(OperationContext operationContext)
         {
             ThrowIfDisposed();
-            return _reference.Instance.GetChannel(cancellationContext);
+            return _reference.Instance.GetChannel(operationContext);
         }
 
-        public Task<IChannelHandle> GetChannelAsync(OperationCancellationContext cancellationContext)
+        public Task<IChannelHandle> GetChannelAsync(OperationContext operationContext)
         {
             ThrowIfDisposed();
-            return _reference.Instance.GetChannelAsync(cancellationContext);
+            return _reference.Instance.GetChannelAsync(operationContext);
         }
 
         public void Dispose()
 
@@ -45,68 +45,68 @@ public ICoreSessionHandle Session
             get { return _session; }
         }
 
-        public IChannelSourceHandle GetReadChannelSource(OperationCancellationContext cancellationContext)
+        public IChannelSourceHandle GetReadChannelSource(OperationContext operationContext)
         {
             ThrowIfDisposed();
             return GetChannelSourceHelper();
         }
 
-        public Task<IChannelSourceHandle> GetReadChannelSourceAsync(OperationCancellationContext cancellationContext)
+        public Task<IChannelSourceHandle> GetReadChannelSourceAsync(OperationContext operationContext)
         {
             ThrowIfDisposed();
             return Task.FromResult(GetChannelSourceHelper());
         }
 
-        public IChannelSourceHandle GetReadChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationCancellationContext cancellationContext)
+        public IChannelSourceHandle GetReadChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationContext operationContext)
         {
-            return GetReadChannelSource(cancellationContext);
+            return GetReadChannelSource(operationContext);
         }
 
-        public Task<IChannelSourceHandle> GetReadChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationCancellationContext cancellationContext)
+        public Task<IChannelSourceHandle> GetReadChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationContext operationContext)
         {
-            return GetReadChannelSourceAsync(cancellationContext);
+            return GetReadChannelSourceAsync(operationContext);
         }
 
-        public IChannelSourceHandle GetWriteChannelSource(OperationCancellationContext cancellationContext)
+        public IChannelSourceHandle GetWriteChannelSource(OperationContext operationContext)
         {
             ThrowIfDisposed();
             return GetChannelSourceHelper();
         }
 
-        public IChannelSourceHandle GetWriteChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationCancellationContext cancellationContext)
+        public IChannelSourceHandle GetWriteChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationContext operationContext)
         {
-            return GetWriteChannelSource(cancellationContext);
+            return GetWriteChannelSource(operationContext);
         }
 
-        public IChannelSourceHandle GetWriteChannelSource(IMayUseSecondaryCriteria mayUseSecondary, OperationCancellationContext cancellationContext)
+        public IChannelSourceHandle GetWriteChannelSource(IMayUseSecondaryCriteria mayUseSecondary, OperationContext operationContext)
         {
-            return GetWriteChannelSource(cancellationContext); // ignore mayUseSecondary
+            return GetWriteChannelSource(operationContext); // ignore mayUseSecondary
         }
 
-        public IChannelSourceHandle GetWriteChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, IMayUseSecondaryCriteria mayUseSecondary, OperationCancellationContext cancellationContext)
+        public IChannelSourceHandle GetWriteChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, IMayUseSecondaryCriteria mayUseSecondary, OperationContext operationContext)
         {
-            return GetWriteChannelSource(mayUseSecondary, cancellationContext);
+            return GetWriteChannelSource(mayUseSecondary, operationContext);
         }
 
-        public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(OperationCancellationContext cancellationContext)
+        public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(OperationContext operationContext)
         {
             ThrowIfDisposed();
             return Task.FromResult(GetChannelSourceHelper());
         }
 
-        public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationCancellationContext cancellationContext)
+        public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationContext operationContext)
         {
-            return GetWriteChannelSourceAsync(cancellationContext);
+            return GetWriteChannelSourceAsync(operationContext);
         }
 
-        public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IMayUseSecondaryCriteria mayUseSecondary, OperationCancellationContext cancellationContext)
+        public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IMayUseSecondaryCriteria mayUseSecondary, OperationContext operationContext)
         {
-            return GetWriteChannelSourceAsync(cancellationContext); // ignore mayUseSecondary
+            return GetWriteChannelSourceAsync(operationContext); // ignore mayUseSecondary
         }
 
-        public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, IMayUseSecondaryCriteria mayUseSecondary, OperationCancellationContext cancellationContext)
+        public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, IMayUseSecondaryCriteria mayUseSecondary, OperationContext operationContext)
         {
-            return GetWriteChannelSourceAsync(mayUseSecondary, cancellationContext);
+            return GetWriteChannelSourceAsync(mayUseSecondary, operationContext);
         }
 
         public void Dispose()
 
@@ -146,7 +146,7 @@ public bool IsInTransaction
             EnsureAbortTransactionCanBeCalled(nameof(AbortTransaction));
 
             // TODO: CSOT implement proper way to obtain the operationCancellationContext
-            var operationCancellationContext = new OperationCancellationContext(Timeout.InfiniteTimeSpan, cancellationToken);
+            var operationCancellationContext = new OperationContext(Timeout.InfiniteTimeSpan, cancellationToken);
             try
             {
                 if (_currentTransaction.IsEmpty)
@@ -197,7 +197,7 @@ public bool IsInTransaction
             EnsureAbortTransactionCanBeCalled(nameof(AbortTransaction));
 
             // TODO: CSOT implement proper way to obtain the operationCancellationContext
-            var operationCancellationContext = new OperationCancellationContext(Timeout.InfiniteTimeSpan, cancellationToken);
+            var operationCancellationContext = new OperationContext(Timeout.InfiniteTimeSpan, cancellationToken);
             try
             {
                 if (_currentTransaction.IsEmpty)
@@ -297,7 +297,7 @@ public long AdvanceTransactionNumber()
             EnsureCommitTransactionCanBeCalled(nameof(CommitTransaction));
 
             // TODO: CSOT implement proper way to obtain the operationCancellationContext
-            var operationCancellationContext = new OperationCancellationContext(Timeout.InfiniteTimeSpan, cancellationToken);
+            var operationCancellationContext = new OperationContext(Timeout.InfiniteTimeSpan, cancellationToken);
             try
             {
                 _isCommitTransactionInProgress = true;
@@ -334,7 +334,7 @@ public long AdvanceTransactionNumber()
             EnsureCommitTransactionCanBeCalled(nameof(CommitTransaction));
 
             // TODO: CSOT implement proper way to obtain the operationCancellationContext
-            var operationCancellationContext = new OperationCancellationContext(Timeout.InfiniteTimeSpan, cancellationToken);
+            var operationCancellationContext = new OperationContext(Timeout.InfiniteTimeSpan, cancellationToken);
             try
             {
                 _isCommitTransactionInProgress = true;
@@ -545,21 +545,21 @@ private void EnsureTransactionsAreSupported()
             }
         }
 
-        private TResult ExecuteEndTransactionOnPrimary<TResult>(IReadOperation<TResult> operation, OperationCancellationContext operationCancellationContext)
+        private TResult ExecuteEndTransactionOnPrimary<TResult>(IReadOperation<TResult> operation, OperationContext operationContext)
         {
             using (var sessionHandle = new NonDisposingCoreSessionHandle(this))
             using (var binding = ChannelPinningHelper.CreateReadWriteBinding(_cluster, sessionHandle))
             {
-                return operation.Execute(binding, operationCancellationContext);
+                return operation.Execute(binding, operationContext);
             }
         }
 
-        private async Task<TResult> ExecuteEndTransactionOnPrimaryAsync<TResult>(IReadOperation<TResult> operation, OperationCancellationContext operationCancellationContext)
+        private async Task<TResult> ExecuteEndTransactionOnPrimaryAsync<TResult>(IReadOperation<TResult> operation, OperationContext operationContext)
         {
             using (var sessionHandle = new NonDisposingCoreSessionHandle(this))
             using (var binding = ChannelPinningHelper.CreateReadWriteBinding(_cluster, sessionHandle))
             {
-                return await operation.ExecuteAsync(binding, operationCancellationContext).ConfigureAwait(false);
+                return await operation.ExecuteAsync(binding, operationContext).ConfigureAwait(false);
             }
         }
Original file line number	Diff line number	Diff line change
`@@ -63,13 +63,13 @@ public void Dispose()`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`
`66`		`- public IChannelHandle GetChannel(OperationCancellationContext cancellationContext)`
	`66`	`+ public IChannelHandle GetChannel(OperationContext operationContext)`
`67`	`67`	`{`
`68`	`68`	`ThrowIfDisposed();`
`69`	`69`	`return GetChannelHelper();`
`70`	`70`	`}`
`71`	`71`
`72`		`- public Task<IChannelHandle> GetChannelAsync(OperationCancellationContext cancellationContext)`
	`72`	`+ public Task<IChannelHandle> GetChannelAsync(OperationContext operationContext)`
`73`	`73`	`{`
`74`	`74`	`ThrowIfDisposed();`
`75`	`75`	`return Task.FromResult(GetChannelHelper());`
Original file line number	Diff line number	Diff line change
`@@ -57,26 +57,26 @@ public void Dispose()`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`
`60`		`- public IChannelSourceHandle GetReadChannelSource(OperationCancellationContext cancellationContext)`
	`60`	`+ public IChannelSourceHandle GetReadChannelSource(OperationContext operationContext)`
`61`	`61`	`{`
`62`	`62`	`ThrowIfDisposed();`
`63`	`63`	`return GetReadChannelSourceHelper();`
`64`	`64`	`}`
`65`	`65`
`66`		`- public Task<IChannelSourceHandle> GetReadChannelSourceAsync(OperationCancellationContext cancellationContext)`
	`66`	`+ public Task<IChannelSourceHandle> GetReadChannelSourceAsync(OperationContext operationContext)`
`67`	`67`	`{`
`68`	`68`	`ThrowIfDisposed();`
`69`	`69`	`return Task.FromResult<IChannelSourceHandle>(GetReadChannelSourceHelper());`
`70`	`70`	`}`
`71`	`71`
`72`		`- public IChannelSourceHandle GetReadChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationCancellationContext cancellationContext)`
	`72`	`+ public IChannelSourceHandle GetReadChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationContext operationContext)`
`73`	`73`	`{`
`74`		`- return GetReadChannelSource(cancellationContext);`
	`74`	`+ return GetReadChannelSource(operationContext);`
`75`	`75`	`}`
`76`	`76`
`77`		`- public Task<IChannelSourceHandle> GetReadChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationCancellationContext cancellationContext)`
	`77`	`+ public Task<IChannelSourceHandle> GetReadChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationContext operationContext)`
`78`	`78`	`{`
`79`		`- return GetReadChannelSourceAsync(cancellationContext);`
	`79`	`+ return GetReadChannelSourceAsync(operationContext);`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`private IChannelSourceHandle GetReadChannelSourceHelper()`
Original file line number	Diff line number	Diff line change
`@@ -55,68 +55,68 @@ public void Dispose()`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`
`58`		`- public IChannelSourceHandle GetReadChannelSource(OperationCancellationContext cancellationContext)`
	`58`	`+ public IChannelSourceHandle GetReadChannelSource(OperationContext operationContext)`
`59`	`59`	`{`
`60`	`60`	`ThrowIfDisposed();`
`61`	`61`	`return GetChannelSourceHelper();`
`62`	`62`	`}`
`63`	`63`
`64`		`- public Task<IChannelSourceHandle> GetReadChannelSourceAsync(OperationCancellationContext cancellationContext)`
	`64`	`+ public Task<IChannelSourceHandle> GetReadChannelSourceAsync(OperationContext operationContext)`
`65`	`65`	`{`
`66`	`66`	`ThrowIfDisposed();`
`67`	`67`	`return Task.FromResult(GetChannelSourceHelper());`
`68`	`68`	`}`
`69`	`69`
`70`		`- public IChannelSourceHandle GetReadChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationCancellationContext cancellationContext)`
	`70`	`+ public IChannelSourceHandle GetReadChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationContext operationContext)`
`71`	`71`	`{`
`72`		`- return GetReadChannelSource(cancellationContext);`
	`72`	`+ return GetReadChannelSource(operationContext);`
`73`	`73`	`}`
`74`	`74`
`75`		`- public Task<IChannelSourceHandle> GetReadChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationCancellationContext cancellationContext)`
	`75`	`+ public Task<IChannelSourceHandle> GetReadChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationContext operationContext)`
`76`	`76`	`{`
`77`		`- return GetReadChannelSourceAsync(cancellationContext);`
	`77`	`+ return GetReadChannelSourceAsync(operationContext);`
`78`	`78`	`}`
`79`	`79`
`80`		`- public IChannelSourceHandle GetWriteChannelSource(OperationCancellationContext cancellationContext)`
	`80`	`+ public IChannelSourceHandle GetWriteChannelSource(OperationContext operationContext)`
`81`	`81`	`{`
`82`	`82`	`ThrowIfDisposed();`
`83`	`83`	`return GetChannelSourceHelper();`
`84`	`84`	`}`
`85`	`85`
`86`		`- public IChannelSourceHandle GetWriteChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationCancellationContext cancellationContext)`
	`86`	`+ public IChannelSourceHandle GetWriteChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationContext operationContext)`
`87`	`87`	`{`
`88`		`- return GetWriteChannelSource(cancellationContext);`
	`88`	`+ return GetWriteChannelSource(operationContext);`
`89`	`89`	`}`
`90`	`90`
`91`		`- public IChannelSourceHandle GetWriteChannelSource(IMayUseSecondaryCriteria mayUseSecondary, OperationCancellationContext cancellationContext)`
	`91`	`+ public IChannelSourceHandle GetWriteChannelSource(IMayUseSecondaryCriteria mayUseSecondary, OperationContext operationContext)`
`92`	`92`	`{`
`93`		`- return GetWriteChannelSource(cancellationContext); // ignore mayUseSecondary`
	`93`	`+ return GetWriteChannelSource(operationContext); // ignore mayUseSecondary`
`94`	`94`	`}`
`95`	`95`
`96`		`- public IChannelSourceHandle GetWriteChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, IMayUseSecondaryCriteria mayUseSecondary, OperationCancellationContext cancellationContext)`
	`96`	`+ public IChannelSourceHandle GetWriteChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, IMayUseSecondaryCriteria mayUseSecondary, OperationContext operationContext)`
`97`	`97`	`{`
`98`		`- return GetWriteChannelSource(mayUseSecondary, cancellationContext);`
	`98`	`+ return GetWriteChannelSource(mayUseSecondary, operationContext);`
`99`	`99`	`}`
`100`	`100`
`101`		`- public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(OperationCancellationContext cancellationContext)`
	`101`	`+ public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(OperationContext operationContext)`
`102`	`102`	`{`
`103`	`103`	`ThrowIfDisposed();`
`104`	`104`	`return Task.FromResult(GetChannelSourceHelper());`
`105`	`105`	`}`
`106`	`106`
`107`		`- public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationCancellationContext cancellationContext)`
	`107`	`+ public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationContext operationContext)`
`108`	`108`	`{`
`109`		`- return GetWriteChannelSourceAsync(cancellationContext);`
	`109`	`+ return GetWriteChannelSourceAsync(operationContext);`
`110`	`110`	`}`
`111`	`111`
`112`		`- public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IMayUseSecondaryCriteria mayUseSecondary, OperationCancellationContext cancellationContext)`
	`112`	`+ public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IMayUseSecondaryCriteria mayUseSecondary, OperationContext operationContext)`
`113`	`113`	`{`
`114`		`- return GetWriteChannelSourceAsync(cancellationContext); // ignore mayUseSecondary`
	`114`	`+ return GetWriteChannelSourceAsync(operationContext); // ignore mayUseSecondary`
`115`	`115`	`}`
`116`	`116`
`117`		`- public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, IMayUseSecondaryCriteria mayUseSecondary, OperationCancellationContext cancellationContext)`
	`117`	`+ public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, IMayUseSecondaryCriteria mayUseSecondary, OperationContext operationContext)`
`118`	`118`	`{`
`119`		`- return GetWriteChannelSourceAsync(mayUseSecondary, cancellationContext);`
	`119`	`+ return GetWriteChannelSourceAsync(mayUseSecondary, operationContext);`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`private IChannelSourceHandle GetChannelSourceHelper()`
Original file line number	Diff line number	Diff line change
`@@ -54,16 +54,16 @@ public ICoreSessionHandle Session`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`// methods`
`57`		`- public IChannelHandle GetChannel(OperationCancellationContext cancellationContext)`
	`57`	`+ public IChannelHandle GetChannel(OperationContext operationContext)`
`58`	`58`	`{`
`59`	`59`	`ThrowIfDisposed();`
`60`		`- return _reference.Instance.GetChannel(cancellationContext);`
	`60`	`+ return _reference.Instance.GetChannel(operationContext);`
`61`	`61`	`}`
`62`	`62`
`63`		`- public Task<IChannelHandle> GetChannelAsync(OperationCancellationContext cancellationContext)`
	`63`	`+ public Task<IChannelHandle> GetChannelAsync(OperationContext operationContext)`
`64`	`64`	`{`
`65`	`65`	`ThrowIfDisposed();`
`66`		`- return _reference.Instance.GetChannelAsync(cancellationContext);`
	`66`	`+ return _reference.Instance.GetChannelAsync(operationContext);`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`public void Dispose()`
Original file line number	Diff line number	Diff line change
`@@ -45,68 +45,68 @@ public ICoreSessionHandle Session`
`45`	`45`	`get { return _session; }`
`46`	`46`	`}`
`47`	`47`
`48`		`- public IChannelSourceHandle GetReadChannelSource(OperationCancellationContext cancellationContext)`
	`48`	`+ public IChannelSourceHandle GetReadChannelSource(OperationContext operationContext)`
`49`	`49`	`{`
`50`	`50`	`ThrowIfDisposed();`
`51`	`51`	`return GetChannelSourceHelper();`
`52`	`52`	`}`
`53`	`53`
`54`		`- public Task<IChannelSourceHandle> GetReadChannelSourceAsync(OperationCancellationContext cancellationContext)`
	`54`	`+ public Task<IChannelSourceHandle> GetReadChannelSourceAsync(OperationContext operationContext)`
`55`	`55`	`{`
`56`	`56`	`ThrowIfDisposed();`
`57`	`57`	`return Task.FromResult(GetChannelSourceHelper());`
`58`	`58`	`}`
`59`	`59`
`60`		`- public IChannelSourceHandle GetReadChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationCancellationContext cancellationContext)`
	`60`	`+ public IChannelSourceHandle GetReadChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationContext operationContext)`
`61`	`61`	`{`
`62`		`- return GetReadChannelSource(cancellationContext);`
	`62`	`+ return GetReadChannelSource(operationContext);`
`63`	`63`	`}`
`64`	`64`
`65`		`- public Task<IChannelSourceHandle> GetReadChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationCancellationContext cancellationContext)`
	`65`	`+ public Task<IChannelSourceHandle> GetReadChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationContext operationContext)`
`66`	`66`	`{`
`67`		`- return GetReadChannelSourceAsync(cancellationContext);`
	`67`	`+ return GetReadChannelSourceAsync(operationContext);`
`68`	`68`	`}`
`69`	`69`
`70`		`- public IChannelSourceHandle GetWriteChannelSource(OperationCancellationContext cancellationContext)`
	`70`	`+ public IChannelSourceHandle GetWriteChannelSource(OperationContext operationContext)`
`71`	`71`	`{`
`72`	`72`	`ThrowIfDisposed();`
`73`	`73`	`return GetChannelSourceHelper();`
`74`	`74`	`}`
`75`	`75`
`76`		`- public IChannelSourceHandle GetWriteChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationCancellationContext cancellationContext)`
	`76`	`+ public IChannelSourceHandle GetWriteChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationContext operationContext)`
`77`	`77`	`{`
`78`		`- return GetWriteChannelSource(cancellationContext);`
	`78`	`+ return GetWriteChannelSource(operationContext);`
`79`	`79`	`}`
`80`	`80`
`81`		`- public IChannelSourceHandle GetWriteChannelSource(IMayUseSecondaryCriteria mayUseSecondary, OperationCancellationContext cancellationContext)`
	`81`	`+ public IChannelSourceHandle GetWriteChannelSource(IMayUseSecondaryCriteria mayUseSecondary, OperationContext operationContext)`
`82`	`82`	`{`
`83`		`- return GetWriteChannelSource(cancellationContext); // ignore mayUseSecondary`
	`83`	`+ return GetWriteChannelSource(operationContext); // ignore mayUseSecondary`
`84`	`84`	`}`
`85`	`85`
`86`		`- public IChannelSourceHandle GetWriteChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, IMayUseSecondaryCriteria mayUseSecondary, OperationCancellationContext cancellationContext)`
	`86`	`+ public IChannelSourceHandle GetWriteChannelSource(IReadOnlyCollection<ServerDescription> deprioritizedServers, IMayUseSecondaryCriteria mayUseSecondary, OperationContext operationContext)`
`87`	`87`	`{`
`88`		`- return GetWriteChannelSource(mayUseSecondary, cancellationContext);`
	`88`	`+ return GetWriteChannelSource(mayUseSecondary, operationContext);`
`89`	`89`	`}`
`90`	`90`
`91`		`- public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(OperationCancellationContext cancellationContext)`
	`91`	`+ public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(OperationContext operationContext)`
`92`	`92`	`{`
`93`	`93`	`ThrowIfDisposed();`
`94`	`94`	`return Task.FromResult(GetChannelSourceHelper());`
`95`	`95`	`}`
`96`	`96`
`97`		`- public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationCancellationContext cancellationContext)`
	`97`	`+ public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, OperationContext operationContext)`
`98`	`98`	`{`
`99`		`- return GetWriteChannelSourceAsync(cancellationContext);`
	`99`	`+ return GetWriteChannelSourceAsync(operationContext);`
`100`	`100`	`}`
`101`	`101`
`102`		`- public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IMayUseSecondaryCriteria mayUseSecondary, OperationCancellationContext cancellationContext)`
	`102`	`+ public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IMayUseSecondaryCriteria mayUseSecondary, OperationContext operationContext)`
`103`	`103`	`{`
`104`		`- return GetWriteChannelSourceAsync(cancellationContext); // ignore mayUseSecondary`
	`104`	`+ return GetWriteChannelSourceAsync(operationContext); // ignore mayUseSecondary`
`105`	`105`	`}`
`106`	`106`
`107`		`- public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, IMayUseSecondaryCriteria mayUseSecondary, OperationCancellationContext cancellationContext)`
	`107`	`+ public Task<IChannelSourceHandle> GetWriteChannelSourceAsync(IReadOnlyCollection<ServerDescription> deprioritizedServers, IMayUseSecondaryCriteria mayUseSecondary, OperationContext operationContext)`
`108`	`108`	`{`
`109`		`- return GetWriteChannelSourceAsync(mayUseSecondary, cancellationContext);`
	`109`	`+ return GetWriteChannelSourceAsync(mayUseSecondary, operationContext);`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`public void Dispose()`
Original file line number	Diff line number	Diff line change
`@@ -146,7 +146,7 @@ public bool IsInTransaction`
`146`	`146`	`EnsureAbortTransactionCanBeCalled(nameof(AbortTransaction));`
`147`	`147`
`148`	`148`	`// TODO: CSOT implement proper way to obtain the operationCancellationContext`
`149`		`- var operationCancellationContext = new OperationCancellationContext(Timeout.InfiniteTimeSpan, cancellationToken);`
	`149`	`+ var operationCancellationContext = new OperationContext(Timeout.InfiniteTimeSpan, cancellationToken);`
`150`	`150`	`try`
`151`	`151`	`{`
`152`	`152`	`if (_currentTransaction.IsEmpty)`
`@@ -197,7 +197,7 @@ public bool IsInTransaction`
`197`	`197`	`EnsureAbortTransactionCanBeCalled(nameof(AbortTransaction));`
`198`	`198`
`199`	`199`	`// TODO: CSOT implement proper way to obtain the operationCancellationContext`
`200`		`- var operationCancellationContext = new OperationCancellationContext(Timeout.InfiniteTimeSpan, cancellationToken);`
	`200`	`+ var operationCancellationContext = new OperationContext(Timeout.InfiniteTimeSpan, cancellationToken);`
`201`	`201`	`try`
`202`	`202`	`{`
`203`	`203`	`if (_currentTransaction.IsEmpty)`
`@@ -297,7 +297,7 @@ public long AdvanceTransactionNumber()`
`297`	`297`	`EnsureCommitTransactionCanBeCalled(nameof(CommitTransaction));`
`298`	`298`
`299`	`299`	`// TODO: CSOT implement proper way to obtain the operationCancellationContext`
`300`		`- var operationCancellationContext = new OperationCancellationContext(Timeout.InfiniteTimeSpan, cancellationToken);`
	`300`	`+ var operationCancellationContext = new OperationContext(Timeout.InfiniteTimeSpan, cancellationToken);`
`301`	`301`	`try`
`302`	`302`	`{`
`303`	`303`	`_isCommitTransactionInProgress = true;`
`@@ -334,7 +334,7 @@ public long AdvanceTransactionNumber()`
`334`	`334`	`EnsureCommitTransactionCanBeCalled(nameof(CommitTransaction));`
`335`	`335`
`336`	`336`	`// TODO: CSOT implement proper way to obtain the operationCancellationContext`
`337`		`- var operationCancellationContext = new OperationCancellationContext(Timeout.InfiniteTimeSpan, cancellationToken);`
	`337`	`+ var operationCancellationContext = new OperationContext(Timeout.InfiniteTimeSpan, cancellationToken);`
`338`	`338`	`try`
`339`	`339`	`{`
`340`	`340`	`_isCommitTransactionInProgress = true;`
`@@ -545,21 +545,21 @@ private void EnsureTransactionsAreSupported()`
`545`	`545`	`}`
`546`	`546`	`}`
`547`	`547`
`548`		`- private TResult ExecuteEndTransactionOnPrimary<TResult>(IReadOperation<TResult> operation, OperationCancellationContext operationCancellationContext)`
	`548`	`+ private TResult ExecuteEndTransactionOnPrimary<TResult>(IReadOperation<TResult> operation, OperationContext operationContext)`
`549`	`549`	`{`
`550`	`550`	`using (var sessionHandle = new NonDisposingCoreSessionHandle(this))`
`551`	`551`	`using (var binding = ChannelPinningHelper.CreateReadWriteBinding(_cluster, sessionHandle))`
`552`	`552`	`{`
`553`		`- return operation.Execute(binding, operationCancellationContext);`
	`553`	`+ return operation.Execute(binding, operationContext);`
`554`	`554`	`}`
`555`	`555`	`}`
`556`	`556`
`557`		`- private async Task<TResult> ExecuteEndTransactionOnPrimaryAsync<TResult>(IReadOperation<TResult> operation, OperationCancellationContext operationCancellationContext)`
	`557`	`+ private async Task<TResult> ExecuteEndTransactionOnPrimaryAsync<TResult>(IReadOperation<TResult> operation, OperationContext operationContext)`
`558`	`558`	`{`
`559`	`559`	`using (var sessionHandle = new NonDisposingCoreSessionHandle(this))`
`560`	`560`	`using (var binding = ChannelPinningHelper.CreateReadWriteBinding(_cluster, sessionHandle))`
`561`	`561`	`{`
`562`		`- return await operation.ExecuteAsync(binding, operationCancellationContext).ConfigureAwait(false);`
	`562`	`+ return await operation.ExecuteAsync(binding, operationContext).ConfigureAwait(false);`
`563`	`563`	`}`
`564`	`564`	`}`
`565`	`565`