// static methods
public static BulkWriteBatchResult Create(
bool isOrdered,
IReadOnlyList <WriteRequest> requests,
BsonDocument writeCommandResponse,
IndexMap indexMap,
MongoWriteConcernException writeConcernException)
{
var writeErrors = CreateWriteErrors(writeCommandResponse);
var writeConcernError = CreateWriteConcernError(writeCommandResponse, writeConcernException);
var processedRequests = CreateProcessedRequests(requests, writeErrors, isOrdered);
var unprocessedRequests = CreateUnprocessedRequests(requests, writeErrors, isOrdered);
var upserts = CreateUpserts(writeCommandResponse);
var n = writeCommandResponse == null ? 0 : writeCommandResponse.GetValue("n", 0).ToInt64();
var matchedCount = 0L;
var deletedCount = 0L;
var insertedCount = 0L;
long?modifiedCount = 0L;
var firstRequest = requests.FirstOrDefault();
if (firstRequest != null)
{
switch (firstRequest.RequestType)
{
case WriteRequestType.Delete:
deletedCount = n;
break;
case WriteRequestType.Insert:
insertedCount = n;
break;
case WriteRequestType.Update:
matchedCount = n - upserts.Count();
BsonValue nModified;
if (writeCommandResponse != null && writeCommandResponse.TryGetValue("nModified", out nModified))
{
modifiedCount = nModified.ToInt64();
}
else
{
modifiedCount = null;
}
break;
}
}
return(new BulkWriteBatchResult(
requests.Count,
processedRequests,
unprocessedRequests,
matchedCount,
deletedCount,
insertedCount,
modifiedCount,
upserts,
writeErrors,
writeConcernError,
indexMap));
}
protected static Exception HandleWriteException(MongoWriteConcernException exception)
{
switch (exception.Code)
{
case 11000:
case 11001:
throw new ConflictException(exception.ErrorMessage, exception);
}
return(new InternalServerErrorException(exception));
}
// private methods
private BulkWriteBatchResult CreateBatchResult(
Batch batch,
BsonDocument writeCommandResult,
MongoWriteConcernException writeConcernException)
{
var requests = batch.Requests;
var requestsInBatch = requests.GetProcessedItems();
var indexMap = new IndexMap.RangeBased(0, requests.Offset, requests.Count);
return(BulkWriteBatchResult.Create(
_isOrdered,
requestsInBatch,
writeCommandResult,
indexMap,
writeConcernException));
}
public static MongoCommandException CreateMongoWriteConcernException(BsonDocument writeConcernResultDocument, string label = null)
{
var clusterId = new ClusterId(1);
var endPoint = new DnsEndPoint("localhost", 27017);
var serverId = new ServerId(clusterId, endPoint);
var connectionId = new ConnectionId(serverId);
var message = "Fake MongoWriteConcernException";
var writeConcernResult = new WriteConcernResult(writeConcernResultDocument);
var writeConcernException = new MongoWriteConcernException(connectionId, message, writeConcernResult);
if (label != null)
{
writeConcernException.AddErrorLabel(label);
}
return(writeConcernException);
}
private async Task <BulkWriteBatchResult> EmulateSingleRequestAsync(IChannelHandle channel, TWriteRequest request, int originalIndex, CancellationToken cancellationToken)
{
WriteConcernResult writeConcernResult = null;
MongoWriteConcernException writeConcernException = null;
try
{
writeConcernResult = await ExecuteProtocolAsync(channel, request, cancellationToken).ConfigureAwait(false);
}
catch (MongoWriteConcernException ex)
{
writeConcernResult = ex.WriteConcernResult;
writeConcernException = ex;
}
return(CreateSingleRequestResult(request, originalIndex, writeConcernResult, writeConcernException));
}
// private methods
private BulkWriteBatchResult EmulateSingleRequest(IChannelHandle channel, TWriteRequest request, int originalIndex, CancellationToken cancellationToken)
{
WriteConcernResult writeConcernResult = null;
MongoWriteConcernException writeConcernException = null;
try
{
writeConcernResult = ExecuteProtocol(channel, request, cancellationToken);
}
catch (MongoWriteConcernException ex)
{
writeConcernResult = ex.WriteConcernResult;
writeConcernException = ex;
}
return(CreateSingleRequestResult(request, originalIndex, writeConcernResult, writeConcernException));
}
public WriteConcernResult HandleException(MongoWriteConcernException exception)
{
var result = exception.WriteConcernResult;
if (_continueOnError)
{
_finalException = exception;
}
else if (_writeConcern.IsAcknowledged)
{
_results.Add(result);
exception.Data["results"] = _results;
throw exception;
}
return(result);
}
private static BulkWriteConcernError CreateWriteConcernError(
BsonDocument writeCommandResponse,
MongoWriteConcernException writeConcernException)
{
if (writeCommandResponse != null && writeCommandResponse.Contains("writeConcernError"))
{
var value = (BsonDocument)writeCommandResponse["writeConcernError"];
var code = value["code"].ToInt32();
var codeName = (string)value.GetValue("codeName", null);
var message = value["errmsg"].AsString;
var details = (BsonDocument)value.GetValue("errInfo", null);
var errorLabels = writeConcernException.ErrorLabels;
return(new BulkWriteConcernError(code, codeName, message, details, errorLabels));
}
return(null);
}
private BulkWriteBatchResult ExecuteBatch(RetryableWriteContext context, Batch batch, CancellationToken cancellationToken)
{
var operation = CreateBatchOperation(batch);
BsonDocument operationResult;
MongoWriteConcernException writeConcernException = null;
try
{
operationResult = RetryableWriteOperationExecutor.Execute(operation, context, cancellationToken);
}
catch (MongoWriteConcernException exception) when(exception.IsWriteConcernErrorOnly())
{
operationResult = exception.Result;
writeConcernException = exception;
}
return(CreateBatchResult(batch, operationResult, writeConcernException));
}
private async Task <BulkWriteBatchResult> ExecuteBatchAsync(RetryableWriteContext context, Batch batch, CancellationToken cancellationToken)
{
var operation = CreateBatchOperation(batch);
BsonDocument operationResult;
MongoWriteConcernException writeConcernException = null;
try
{
operationResult = await RetryableWriteOperationExecutor.ExecuteAsync(operation, context, cancellationToken).ConfigureAwait(false);
}
catch (MongoWriteConcernException exception) when(exception.IsWriteConcernErrorOnly())
{
operationResult = exception.Result;
writeConcernException = exception;
}
return(CreateBatchResult(batch, operationResult, writeConcernException));
}
// public methods
public Exception ToWriteConcernException(ConnectionId connectionId, MongoBulkWriteOperationException bulkWriteException)
{
var writeConcernResult = ToWriteConcernResult(bulkWriteException.Result, bulkWriteException);
var exception = ExceptionMapper.Map(connectionId, writeConcernResult.Response);
if (exception == null)
{
exception = ExceptionMapper.Map(connectionId, writeConcernResult);
}
if (exception == null)
{
exception = new MongoWriteConcernException(connectionId, bulkWriteException.Message, writeConcernResult);
}
var writeConcernException = exception as MongoWriteConcernException;
if (writeConcernException != null)
{
writeConcernException.Data["results"] = new List<WriteConcernResult>(new[] { writeConcernResult });
}
return exception; // usually a WriteConcernException unless ExceptionMapper chose a different type
}
internal void ShouldInvalidateServer_should_return_expected_result_for_MongoWriteConcernException(ServerErrorCode?code, string message, bool expectedResult)
{
_subject.Initialize();
var clusterId = new ClusterId(1);
var serverId = new ServerId(clusterId, new DnsEndPoint("localhost", 27017));
var connectionId = new ConnectionId(serverId);
var command = new BsonDocument("command", 1);
var commandResult = new BsonDocument
{
{ "ok", 1 },
{ "writeConcernError", new BsonDocument
{
{ "code", () => (int)code.Value, code.HasValue },
{ "errmsg", message, message != null }
} }
};
var writeConcernResult = new WriteConcernResult(commandResult);
var exception = new MongoWriteConcernException(connectionId, "message", writeConcernResult);
var result = _subject.ShouldInvalidateServer(Mock.Of <IConnection>(), exception, new ServerDescription(_subject.ServerId, _subject.EndPoint), out _);
result.Should().Be(expectedResult);
}
// methods
protected virtual async Task <BulkWriteBatchResult> EmulateSingleRequestAsync(IChannelHandle channel, WriteRequest request, int originalIndex, CancellationToken cancellationToken)
{
WriteConcernResult writeConcernResult = null;
MongoWriteConcernException writeConcernException = null;
try
{
writeConcernResult = await ExecuteProtocolAsync(channel, request, cancellationToken).ConfigureAwait(false);
}
catch (MongoWriteConcernException ex)
{
writeConcernResult = ex.WriteConcernResult;
writeConcernException = ex;
}
var indexMap = new IndexMap.RangeBased(0, originalIndex, 1);
return(BulkWriteBatchResult.Create(
request,
writeConcernResult,
writeConcernException,
indexMap));
}
// public methods
public Exception ToWriteConcernException(ConnectionId connectionId, MongoBulkWriteOperationException bulkWriteException)
{
var writeConcernResult = ToWriteConcernResult(bulkWriteException.Result, bulkWriteException);
var exception = ExceptionMapper.Map(connectionId, writeConcernResult.Response);
if (exception == null)
{
exception = ExceptionMapper.Map(connectionId, writeConcernResult);
}
if (exception == null)
{
exception = new MongoWriteConcernException(connectionId, bulkWriteException.Message, writeConcernResult);
}
var writeConcernException = exception as MongoWriteConcernException;
if (writeConcernException != null)
{
writeConcernException.Data["results"] = new List <WriteConcernResult>(new[] { writeConcernResult });
}
return(exception); // usually a WriteConcernException unless ExceptionMapper chose a different type
}
public static BulkWriteBatchResult Create(
WriteRequest request,
WriteConcernResult writeConcernResult,
MongoWriteConcernException writeConcernException,
IndexMap indexMap)
{
var processedRequests = new[] { request };
var unprocessedRequests = __noWriteRequests;
BsonValue upsertId = null;
var documentsAffected = 0L;
if (writeConcernResult != null)
{
upsertId = writeConcernResult.Upserted;
documentsAffected = writeConcernResult.DocumentsAffected;
var updateRequest = request as UpdateRequest;
if (upsertId == null &&
documentsAffected == 1 &&
updateRequest != null &&
updateRequest.IsUpsert &&
!writeConcernResult.UpdatedExisting)
{
// Get the _id field first from the Update document
// and then from the Query document.
upsertId =
updateRequest.Update.ToBsonDocument().GetValue("_id", null) ??
updateRequest.Filter.ToBsonDocument().GetValue("_id", null);
}
}
var upserts = (upsertId == null) ? __noUpserts : new[] { new BulkWriteOperationUpsert(0, upsertId) };
var writeErrors = __noWriteErrors;
BulkWriteConcernError writeConcernError = null;
if (writeConcernException != null)
{
var getLastErrorResponse = writeConcernResult.Response;
if (IsGetLasterrorResponseAWriteConcernError(getLastErrorResponse))
{
writeConcernError = CreateWriteConcernErrorFromGetLastErrorResponse(getLastErrorResponse);
}
else
{
writeErrors = new[] { CreateWriteErrorFromGetLastErrorResponse(getLastErrorResponse) };
}
}
if (request.RequestType == WriteRequestType.Insert && writeErrors.Count == 0)
{
documentsAffected = 1; // note: DocumentsAffected is 0 for inserts
}
var matchedCount = 0L;
var deletedCount = 0L;
var insertedCount = 0L;
long? modifiedCount = 0L;
switch (request.RequestType)
{
case WriteRequestType.Delete:
deletedCount = documentsAffected;
break;
case WriteRequestType.Insert:
insertedCount = documentsAffected;
break;
case WriteRequestType.Update:
matchedCount = documentsAffected - upserts.Count();
modifiedCount = null; // getLasterror does not report this value
break;
}
return new BulkWriteBatchResult(
1, // batchCount
processedRequests,
unprocessedRequests,
matchedCount,
deletedCount,
insertedCount,
modifiedCount,
upserts,
writeErrors,
writeConcernError,
indexMap);
}
private BulkWriteBatchResult CreateSingleRequestResult(TWriteRequest request, int originalIndex, WriteConcernResult writeConcernResult, MongoWriteConcernException writeConcernException)
{
var indexMap = new IndexMap.RangeBased(0, originalIndex, 1);
return(BulkWriteBatchResult.Create(
request,
writeConcernResult,
writeConcernException,
indexMap));
}
private BulkWriteBatchResult CreateSingleRequestResult(WriteRequest request, int originalIndex, WriteConcernResult writeConcernResult, MongoWriteConcernException writeConcernException)
{
var indexMap = new IndexMap.RangeBased(0, originalIndex, 1);
return BulkWriteBatchResult.Create(
request,
writeConcernResult,
writeConcernException,
indexMap);
}
public static BulkWriteBatchResult Create(
WriteRequest request,
WriteConcernResult writeConcernResult,
MongoWriteConcernException writeConcernException,
IndexMap indexMap)
{
var processedRequests = new[] { request };
var unprocessedRequests = __noWriteRequests;
BsonValue upsertId = null;
var documentsAffected = 0L;
if (writeConcernResult != null)
{
upsertId = writeConcernResult.Upserted;
documentsAffected = writeConcernResult.DocumentsAffected;
var updateRequest = request as UpdateRequest;
if (upsertId == null &&
documentsAffected == 1 &&
updateRequest != null &&
updateRequest.IsUpsert &&
!writeConcernResult.UpdatedExisting)
{
// Get the _id field first from the Update document
// and then from the Query document.
upsertId =
updateRequest.Update.ToBsonDocument().GetValue("_id", null) ??
updateRequest.Filter.ToBsonDocument().GetValue("_id", null);
}
}
var upserts = (upsertId == null) ? __noUpserts : new[] { new BulkWriteOperationUpsert(0, upsertId) };
var writeErrors = __noWriteErrors;
BulkWriteConcernError writeConcernError = null;
if (writeConcernException != null)
{
var getLastErrorResponse = writeConcernResult.Response;
if (IsGetLasterrorResponseAWriteConcernError(getLastErrorResponse))
{
writeConcernError = CreateWriteConcernErrorFromGetLastErrorResponse(getLastErrorResponse);
}
else
{
writeErrors = new[] { CreateWriteErrorFromGetLastErrorResponse(getLastErrorResponse) };
}
}
if (request.RequestType == WriteRequestType.Insert && writeErrors.Count == 0)
{
documentsAffected = 1; // note: DocumentsAffected is 0 for inserts
}
var matchedCount = 0L;
var deletedCount = 0L;
var insertedCount = 0L;
long?modifiedCount = 0L;
switch (request.RequestType)
{
case WriteRequestType.Delete:
deletedCount = documentsAffected;
break;
case WriteRequestType.Insert:
insertedCount = documentsAffected;
break;
case WriteRequestType.Update:
matchedCount = documentsAffected - upserts.Count();
modifiedCount = null; // getLasterror does not report this value
break;
}
return(new BulkWriteBatchResult(
1, // batchCount
processedRequests,
unprocessedRequests,
matchedCount,
deletedCount,
insertedCount,
modifiedCount,
upserts,
writeErrors,
writeConcernError,
indexMap));
}
