private IEnumerable <TDocument> DeserializeDocuments(IEnumerable <RawBsonDocument> rawDocuments)
{
var documents = new List <TDocument>();
RawBsonDocument lastRawDocument = null;
foreach (var rawDocument in rawDocuments)
{
if (!rawDocument.Contains("_id"))
{
throw new MongoClientException("Cannot provide resume functionality when the resume token is missing.");
}
var document = DeserializeDocument(rawDocument);
documents.Add(document);
lastRawDocument = rawDocument;
}
if (lastRawDocument != null)
{
_changeStreamOperation.DocumentResumeToken = lastRawDocument["_id"].DeepClone().AsBsonDocument;
}
return(documents);
}
private TResult ProcessCommandResult(ConnectionId connectionId, RawBsonDocument rawBsonDocument)
{
var binaryReaderSettings = new BsonBinaryReaderSettings
{
Encoding = _messageEncoderSettings.GetOrDefault <UTF8Encoding>(MessageEncoderSettingsName.ReadEncoding, Utf8Encodings.Strict),
GuidRepresentation = _messageEncoderSettings.GetOrDefault <GuidRepresentation>(MessageEncoderSettingsName.GuidRepresentation, GuidRepresentation.CSharpLegacy)
};
BsonValue writeConcernError;
if (rawBsonDocument.TryGetValue("writeConcernError", out writeConcernError))
{
var message = writeConcernError["errmsg"].AsString;
var response = rawBsonDocument.Materialize(binaryReaderSettings);
var writeConcernResult = new WriteConcernResult(response);
throw new MongoWriteConcernException(connectionId, message, writeConcernResult);
}
using (var stream = new ByteBufferStream(rawBsonDocument.Slice, ownsBuffer: false))
using (var reader = new BsonBinaryReader(stream, binaryReaderSettings))
{
var context = BsonDeserializationContext.CreateRoot(reader);
return(_resultSerializer.Deserialize(context));
}
}
private async Task ProcessNeedMongoMarkingsStateAsync(CryptContext context, string databaseName, CancellationToken cancellationToken)
{
var database = _mongocryptdClient.GetDatabase(databaseName);
var commandBytes = context.GetOperation().ToArray();
var commandDocument = new RawBsonDocument(commandBytes);
var command = new BsonDocumentCommand <BsonDocument>(commandDocument);
BsonDocument response = null;
for (var attempt = 1; response == null; attempt++)
{
try
{
response = await database.RunCommandAsync(command, cancellationToken : cancellationToken).ConfigureAwait(false);
}
catch (TimeoutException) when(attempt == 1)
{
_mongocryptdFactory.SpawnMongocryptdProcessIfRequired();
await WaitForMongocryptdReadyAsync().ConfigureAwait(false);
}
}
RestoreDbNodeInResponse(commandDocument, response);
FeedResult(context, response);
}
// public methods
public Guid CreateDataKey(
string kmsProvider,
IReadOnlyList <string> alternateKeyNames,
BsonDocument masterKey,
CancellationToken cancellationToken)
{
try
{
var kmsKeyId = GetKmsKeyId(kmsProvider, alternateKeyNames, masterKey);
using (var context = _cryptClient.StartCreateDataKeyContext(kmsKeyId))
{
var wrappedKeyBytes = ProcessStates(context, _keyVaultNamespace.DatabaseNamespace.DatabaseName, cancellationToken);
var wrappedKeyDocument = new RawBsonDocument(wrappedKeyBytes);
var keyId = UnwrapKeyId(wrappedKeyDocument);
_keyVaultCollection.Value.InsertOne(wrappedKeyDocument, cancellationToken: cancellationToken);
return(keyId);
}
}
catch (Exception ex)
{
throw new MongoEncryptionException(ex);
}
}
public override Quaternion Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var rawDoc = context.Reader.ReadRawBsonDocument();
var doc = new RawBsonDocument(rawDoc);
Boolean providedX = doc.Contains("X");
Boolean providedY = doc.Contains("Y");
Boolean providedZ = doc.Contains("Z");
Boolean providedW = doc.Contains("W");
if (providedX && providedY && providedZ && providedW)
{
var vector = new Vector3(
(float)doc.GetElement("X").Value.AsDouble,
(float)doc.GetElement("Y").Value.AsDouble,
(float)doc.GetElement("Z").Value.AsDouble
);
var quaternion = new Quaternion(vector, (float)doc.GetElement("W").Value.AsDouble);
return(quaternion);
}
else
{
Logger.Error("Deserialization Problem - Data Structure is not valid");
throw new ApplicationException("Deserialization Problem - Data Structure is not valid");
}
}
private Type0CommandMessageSection <RawBsonDocument> CreateType0Section(BsonDocument document = null)
{
document = document ?? new BsonDocument("t", 0);
var rawBson = new RawBsonDocument(document.ToBson());
return(new Type0CommandMessageSection <RawBsonDocument>(rawBson, RawBsonDocumentSerializer.Instance));
}
public void DeserializeBatch_should_return_expected_result_when_GuidRepresentation_is_Standard()
{
var document = BsonDocument.Parse("{ batch : [ { a : HexData(4, \"0102030405060708090a0b0c0d0e0f10\") } ] }");
#pragma warning disable 618
var writerSettings = new BsonBinaryWriterSettings();
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2)
{
writerSettings.GuidRepresentation = GuidRepresentation.Standard;
}
#pragma warning restore 618
var bson = document.ToBson(writerSettings: writerSettings);
var rawDocument = new RawBsonDocument(bson);
var batch = (RawBsonArray)rawDocument["batch"];
var documentSerializer = BsonDocumentSerializer.Instance;
var messageEncoderSettings = new MessageEncoderSettings {
{ "GuidRepresentation", GuidRepresentation.Standard }
};
var result = CursorBatchDeserializationHelper.DeserializeBatch <BsonDocument>(batch, documentSerializer, messageEncoderSettings);
result.Count.Should().Be(1);
result[0].Should().BeOfType <BsonDocument>();
result[0].Should().Be("{ a : HexData(4, \"0102030405060708090a0b0c0d0e0f10\") }");
}
public async Task <Guid> CreateDataKeyAsync(
string kmsProvider,
IReadOnlyList <string> alternateKeyNames,
BsonDocument masterKey,
CancellationToken cancellationToken)
{
try
{
ThrowIfUnsupportedPlatform();
var kmsKeyId = GetKmsKeyId(kmsProvider, alternateKeyNames, masterKey);
using (var context = _cryptClient.StartCreateDataKeyContext(kmsKeyId))
{
var wrappedKeyBytes = await ProcessStatesAsync(context, _keyVaultNamespace.DatabaseNamespace.DatabaseName, cancellationToken).ConfigureAwait(false);
var wrappedKeyDocument = new RawBsonDocument(wrappedKeyBytes);
var keyId = UnwrapKeyId(wrappedKeyDocument);
await _keyVaultCollection.Value.InsertOneAsync(wrappedKeyDocument, cancellationToken : cancellationToken).ConfigureAwait(false);
return(keyId);
}
}
catch (Exception ex)
{
throw new MongoEncryptionException(ex);
}
}
public void Dispose()
{
if (D != null)
{
D.Dispose();
D = null;
}
}
public object Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var parser = new JsonParser(JsonParser.Settings.Default);
var buffer = context.Reader.ReadRawBsonDocument();
var json = new RawBsonDocument(buffer).ToJson();
var jObject = JObject.Parse(json);
return parser.Parse<T>(jObject.ToString());
}
private TDocument DeserializeDocument(RawBsonDocument rawDocument)
{
using (var stream = new ByteBufferStream(rawDocument.Slice, ownsBuffer: false))
using (var reader = new BsonBinaryReader(stream))
{
var context = BsonDeserializationContext.CreateRoot(reader);
return(_documentSerializer.Deserialize(context));
}
}
private void ProcessNeedMongoKeysState(CryptContext context, CancellationToken cancellationToken)
{
var filterBytes = context.GetOperation().ToArray();
var filterDocument = new RawBsonDocument(filterBytes);
var filter = new BsonDocumentFilterDefinition <BsonDocument>(filterDocument);
var cursor = _keyVaultCollection.Value.FindSync(filter, cancellationToken: cancellationToken);
var results = cursor.ToList(cancellationToken);
FeedResults(context, results);
}
private Guid UnwrapKeyId(RawBsonDocument wrappedKeyDocument)
{
var keyId = wrappedKeyDocument["_id"].AsBsonBinaryData;
if (keyId.SubType != BsonBinarySubType.UuidStandard)
{
throw new InvalidOperationException($"KeyId sub type must be UuidStandard, not: {keyId.SubType}.");
}
return(GuidConverter.FromBytes(keyId.Bytes, GuidRepresentation.Standard));
}
private async Task ProcessNeedMongoKeysStateAsync(CryptContext context, CancellationToken cancellationToken)
{
var filterBytes = context.GetOperation().ToArray();
var filterDocument = new RawBsonDocument(filterBytes);
var filter = new BsonDocumentFilterDefinition <BsonDocument>(filterDocument);
var cursor = await _keyVaultCollection.Value.FindAsync(filter, cancellationToken : cancellationToken).ConfigureAwait(false);
var results = await cursor.ToListAsync(cancellationToken).ConfigureAwait(false);
FeedResults(context, results);
}
private TDocument DeserializeDocument(RawBsonDocument rawDocument)
{
var slice = rawDocument.Slice;
var bytes = slice.AccessBackingBytes(0);
using (var memoryStream = new MemoryStream(bytes.Array, bytes.Offset, bytes.Count))
using (var reader = new BsonBinaryReader(memoryStream))
{
var context = BsonDeserializationContext.CreateRoot(reader);
return(_documentSerializer.Deserialize(context));
}
}
private CommandRequestMessage CreateEncryptedRequestMessage(CommandRequestMessage unencryptedRequestMessage, byte[] encryptedDocumentBytes)
{
var encryptedDocument = new RawBsonDocument(encryptedDocumentBytes);
var encryptedSections = new[] { new Type0CommandMessageSection <RawBsonDocument>(encryptedDocument, RawBsonDocumentSerializer.Instance) };
var unencryptedCommandMessage = unencryptedRequestMessage.WrappedMessage;
var encryptedCommandMessage = new CommandMessage(
unencryptedCommandMessage.RequestId,
unencryptedCommandMessage.ResponseTo,
encryptedSections,
unencryptedCommandMessage.MoreToCome);
return(new CommandRequestMessage(encryptedCommandMessage, unencryptedRequestMessage.ShouldBeSent));
}
public static CommandResponseMessage BuildCommandResponse(
RawBsonDocument command,
int requestId = 0,
int responseTo = 0,
bool moreToCome = false)
{
return(new CommandResponseMessage(
new CommandMessage(
requestId: requestId,
responseTo: responseTo,
sections: new[] { new Type0CommandMessageSection <RawBsonDocument>(command, RawBsonDocumentSerializer.Instance) },
moreToCome: moreToCome)));
}
public void DeserializeBatch_should_return_expected_result_when_batch_is_empty()
{
var document = BsonDocument.Parse("{ batch : [ ] }");
var bson = document.ToBson();
var rawDocument = new RawBsonDocument(bson);
var batch = (RawBsonArray)rawDocument["batch"];
var documentSerializer = BsonDocumentSerializer.Instance;
var messageEncoderSettings = new MessageEncoderSettings();
var result = CursorBatchDeserializationHelper.DeserializeBatch <BsonDocument>(batch, documentSerializer, messageEncoderSettings);
result.Count.Should().Be(0);
}
// private methods
private void ProcessNeedCollectionInfoState(CryptContext context, string databaseName, CancellationToken cancellationToken)
{
var database = _client.GetDatabase(databaseName);
var filterBytes = context.GetOperation().ToArray();
var filterDocument = new RawBsonDocument(filterBytes);
var filter = new BsonDocumentFilterDefinition <BsonDocument>(filterDocument);
var options = new ListCollectionsOptions {
Filter = filter
};
var cursor = database.ListCollections(options, cancellationToken);
var results = cursor.ToList(cancellationToken);
FeedResults(context, results);
}
public void TestMaterialize(
[Values(0, 1, 2)] int count)
{
var array = new BsonArray(Enumerable.Range(0, count));
var document = new BsonDocument("array", array);
var bytes = document.ToBson();
var rawDocument = new RawBsonDocument(bytes);
var subject = (RawBsonArray)rawDocument["array"];
var binaryReaderSettings = new BsonBinaryReaderSettings();
var result = subject.Materialize(binaryReaderSettings);
result.Should().BeOfType <BsonArray>();
result.Should().Be(array);
}
private async Task ProcessNeedCollectionInfoStateAsync(CryptContext context, string databaseName, CancellationToken cancellationToken)
{
var database = _client.GetDatabase(databaseName);
var filterBytes = context.GetOperation().ToArray();
var filterDocument = new RawBsonDocument(filterBytes);
var filter = new BsonDocumentFilterDefinition <BsonDocument>(filterDocument);
var options = new ListCollectionsOptions {
Filter = filter
};
var cursor = await database.ListCollectionsAsync(options, cancellationToken).ConfigureAwait(false);
var results = await cursor.ToListAsync(cancellationToken).ConfigureAwait(false);
FeedResults(context, results);
}
private TResult ProcessCommandResult(ConnectionId connectionId, RawBsonDocument rawBsonDocument)
{
var binaryReaderSettings = new BsonBinaryReaderSettings
{
Encoding = _messageEncoderSettings.GetOrDefault <UTF8Encoding>(MessageEncoderSettingsName.ReadEncoding, Utf8Encodings.Strict),
GuidRepresentation = _messageEncoderSettings.GetOrDefault <GuidRepresentation>(MessageEncoderSettingsName.GuidRepresentation, GuidRepresentation.CSharpLegacy)
};
using (var stream = new ByteBufferStream(rawBsonDocument.Slice, ownsBuffer: false))
using (var reader = new BsonBinaryReader(stream, binaryReaderSettings))
{
var context = BsonDeserializationContext.CreateRoot(reader);
return(_resultSerializer.Deserialize(context));
}
}
// private methods
private void ProcessNeedCollectionInfoState(CryptContext context, string databaseName, CancellationToken cancellationToken)
{
if (_metadataClient == null)
{
// should not be reached
throw new InvalidOperationException("Metadata client is null.");
}
var database = _metadataClient.GetDatabase(databaseName);
var filterBytes = context.GetOperation().ToArray();
var filterDocument = new RawBsonDocument(filterBytes);
var filter = new BsonDocumentFilterDefinition <BsonDocument>(filterDocument);
var options = new ListCollectionsOptions {
Filter = filter
};
var cursor = database.ListCollections(options, cancellationToken);
var results = cursor.ToList(cancellationToken);
FeedResults(context, results);
}
public RawDictionary(RawBsonDocument value) : base(value)
{
}
private BsonBinaryData UnwrapEncryptedValue(byte[] encryptedWrappedBytes)
{
var wrappedDocument = new RawBsonDocument(encryptedWrappedBytes);
return(wrappedDocument["v"].AsBsonBinaryData);
}
private BsonValue UnwrapDecryptedValue(byte[] wrappedBytes)
{
var wrappedDocument = new RawBsonDocument(wrappedBytes);
return(wrappedDocument["v"]);
}
