public ServiceCredentials() { this.userName = new UserNamePasswordServiceCredential(); this.clientCertificate = new X509CertificateInitiatorServiceCredential(); this.serviceCertificate = new X509CertificateRecipientServiceCredential(); this.windows = new WindowsServiceCredential(); this.issuedToken = new IssuedTokenServiceCredential(); this.peer = new PeerCredential(); this.secureConversation = new SecureConversationServiceCredential(); this.exceptionMapper = new ExceptionMapper(); this.UseIdentityConfiguration = false; }
public SecurityTokenAuthenticatorAdapter(SecurityTokenHandler securityTokenHandler, ExceptionMapper exceptionMapper) { if (securityTokenHandler == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("securityTokenHandler"); } if (exceptionMapper == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("exceptionMapper"); } _securityTokenHandler = securityTokenHandler; _exceptionMapper = exceptionMapper; }
/// <summary> /// Initializes an instance of <see cref="WrappedSaml2SecurityTokenAuthenticator"/> /// </summary> /// <param name="saml2SecurityTokenHandler">The Saml2SecurityTokenHandler to wrap.</param> /// <param name="exceptionMapper">Converts token validation exceptions to SOAP faults.</param> public WrappedSaml2SecurityTokenAuthenticator( Saml2SecurityTokenHandler saml2SecurityTokenHandler, ExceptionMapper exceptionMapper ) { if ( saml2SecurityTokenHandler == null ) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull( "wrappedSaml2SecurityTokenHandler" ); } if ( exceptionMapper == null ) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull( "exceptionMapper" ); } _wrappedSaml2SecurityTokenHandler = saml2SecurityTokenHandler; _exceptionMapper = exceptionMapper; }
protected ServiceCredentials(ServiceCredentials other) { if (other == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("other"); } this.userName = new UserNamePasswordServiceCredential(other.userName); this.clientCertificate = new X509CertificateInitiatorServiceCredential(other.clientCertificate); this.serviceCertificate = new X509CertificateRecipientServiceCredential(other.serviceCertificate); this.windows = new WindowsServiceCredential(other.windows); this.issuedToken = new IssuedTokenServiceCredential(other.issuedToken); this.peer = new PeerCredential(other.peer); this.secureConversation = new SecureConversationServiceCredential(other.secureConversation); this.identityConfiguration = other.identityConfiguration; this.saveBootstrapTokenInSession = other.saveBootstrapTokenInSession; this.exceptionMapper = other.exceptionMapper; this.UseIdentityConfiguration = other.useIdentityConfiguration; }
/// <summary> /// Initializes an instance of <see cref="WrappedRsaSecurityTokenAuthenticator"/> /// </summary> /// <param name="wrappedRsaSecurityTokenHandler">The RsaSecurityTokenHandler to wrap.</param> /// <param name="exceptionMapper">Converts token validation exceptions to SOAP faults.</param> public WrappedRsaSecurityTokenAuthenticator( RsaSecurityTokenHandler wrappedRsaSecurityTokenHandler, ExceptionMapper exceptionMapper ) : base() { if ( wrappedRsaSecurityTokenHandler == null ) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull( "wrappedRsaSecurityTokenHandler" ); } if ( exceptionMapper == null ) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull( "exceptionMapper" ); } _wrappedRsaSecurityTokenHandler = wrappedRsaSecurityTokenHandler; _exceptionMapper = exceptionMapper; }
/// <summary> /// Initializes an instance of <see cref="WrappedX509SecurityTokenAuthenticator"/> /// </summary> /// <param name="wrappedX509SecurityTokenHandler">X509SecurityTokenHandler to wrap.</param> /// <param name="exceptionMapper">Converts token validation exceptions to SOAP faults.</param> public WrappedX509SecurityTokenAuthenticator( X509SecurityTokenHandler wrappedX509SecurityTokenHandler, ExceptionMapper exceptionMapper) : base(X509CertificateValidator.None, GetMapToWindowsSetting(wrappedX509SecurityTokenHandler), true) { if (wrappedX509SecurityTokenHandler == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("wrappedX509SecurityTokenHandler"); } if (exceptionMapper == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("exceptionMapper"); } _wrappedX509SecurityTokenHandler = wrappedX509SecurityTokenHandler; _exceptionMapper = exceptionMapper; }
/// <summary> /// Initializes an instance of <see cref="WrappedRsaSecurityTokenAuthenticator"/> /// </summary> /// <param name="wrappedRsaSecurityTokenHandler">The RsaSecurityTokenHandler to wrap.</param> /// <param name="exceptionMapper">Converts token validation exceptions to SOAP faults.</param> public WrappedRsaSecurityTokenAuthenticator( RsaSecurityTokenHandler wrappedRsaSecurityTokenHandler, ExceptionMapper exceptionMapper) : base() { if (wrappedRsaSecurityTokenHandler == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("wrappedRsaSecurityTokenHandler"); } if (exceptionMapper == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("exceptionMapper"); } _wrappedRsaSecurityTokenHandler = wrappedRsaSecurityTokenHandler; _exceptionMapper = exceptionMapper; }
/// <summary> /// Initializes an instance of <see cref="WrappedSaml11SecurityTokenAuthenticator"/> /// </summary> /// <param name="saml11SecurityTokenHandler">The Saml11SecurityTokenHandler to wrap.</param> /// <param name="exceptionMapper">Converts token validation exceptions to SOAP faults.</param> public WrappedSaml11SecurityTokenAuthenticator( SamlSecurityTokenHandler saml11SecurityTokenHandler, ExceptionMapper exceptionMapper) : base(new List <SecurityTokenAuthenticator>()) { if (saml11SecurityTokenHandler == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("wrappedSaml11SecurityTokenHandler"); } if (exceptionMapper == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("exceptionMapper"); } _wrappedSaml11SecurityTokenHandler = saml11SecurityTokenHandler; _exceptionMapper = exceptionMapper; }
/// <summary> /// Initializes an instance of <see cref="WrappedX509SecurityTokenAuthenticator"/> /// </summary> /// <param name="wrappedX509SecurityTokenHandler">X509SecurityTokenHandler to wrap.</param> /// <param name="exceptionMapper">Converts token validation exceptions to SOAP faults.</param> public WrappedX509SecurityTokenAuthenticator( X509SecurityTokenHandler wrappedX509SecurityTokenHandler, ExceptionMapper exceptionMapper ) : base( X509CertificateValidator.None, GetMapToWindowsSetting( wrappedX509SecurityTokenHandler ), true ) { if ( wrappedX509SecurityTokenHandler == null ) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull( "wrappedX509SecurityTokenHandler" ); } if ( exceptionMapper == null ) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull( "exceptionMapper" ); } _wrappedX509SecurityTokenHandler = wrappedX509SecurityTokenHandler; _exceptionMapper = exceptionMapper; }
internal void IsRecovering_should_return_expected_result_for_message(string message, bool expectedResult) { var commandResult = new BsonDocument { { "ok", 0 }, { "errmsg", message, message != null } }; var exception = ExceptionMapper.MapNotPrimaryOrNodeIsRecovering(_connectionId, new BsonDocument(), commandResult, "errmsg"); if (expectedResult) { exception.Should().BeOfType <MongoNodeIsRecoveringException>(); } else { exception.Should().BeNull(); } }
/// <summary> /// Initializes an instance of <see cref="FederatedSecurityTokenManager"/>. /// </summary> /// <param name="parentCredentials">ServiceCredentials that created this instance of TokenManager.</param> /// <exception cref="ArgumentNullException">The argument 'parentCredentials' is null.</exception> public FederatedSecurityTokenManager(ServiceCredentials parentCredentials) : base(parentCredentials) { if (parentCredentials == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("parentCredentials"); } if (parentCredentials.IdentityConfiguration == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("parentCredentials.IdentityConfiguration"); } _exceptionMapper = parentCredentials.ExceptionMapper; _securityTokenHandlerCollection = parentCredentials.IdentityConfiguration.SecurityTokenHandlers; _tokenCache = _securityTokenHandlerCollection.Configuration.Caches.SessionSecurityTokenCache; _cookieTransforms = SessionSecurityTokenHandler.DefaultCookieTransforms; }
internal void IsNotWritablePrimary_should_return_expected_result_for_code(ServerErrorCode?code, bool expectedResult, Type expectedExceptionType) { var commandResult = new BsonDocument { { "ok", 0 }, { "code", code, code != null } }; var exception = ExceptionMapper.MapNotPrimaryOrNodeIsRecovering(_connectionId, new BsonDocument(), commandResult, "errmsg"); if (expectedExceptionType != null) { exception.Should().BeOfType(expectedExceptionType); } else { exception.Should().BeNull(); } }
/// <summary> /// Initializes an instance of <see cref="FederatedSecurityTokenManager"/>. /// </summary> /// <param name="parentCredentials">ServiceCredentials that created this instance of TokenManager.</param> /// <exception cref="ArgumentNullException">The argument 'parentCredentials' is null.</exception> public FederatedSecurityTokenManager( ServiceCredentials parentCredentials ) : base( parentCredentials ) { if ( parentCredentials == null ) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull( "parentCredentials" ); } if ( parentCredentials.IdentityConfiguration == null ) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull( "parentCredentials.IdentityConfiguration" ); } _exceptionMapper = parentCredentials.ExceptionMapper; _securityTokenHandlerCollection = parentCredentials.IdentityConfiguration.SecurityTokenHandlers; _tokenCache = _securityTokenHandlerCollection.Configuration.Caches.SessionSecurityTokenCache; _cookieTransforms = SessionSecurityTokenHandler.DefaultCookieTransforms; }
private CursorBatch <TDocument> ProcessReply(ReplyMessage <TDocument> reply) { if (reply.QueryFailure) { var document = reply.QueryFailureDocument; var mappedException = ExceptionMapper.Map(document); if (mappedException != null) { throw mappedException; } var err = document.GetValue("$err", "Unknown error."); var message = string.Format("QueryFailure flag was {0} (response was {1}).", err, document.ToJson()); throw new MongoQueryException(message, _query, document); } return(new CursorBatch <TDocument>(reply.CursorId, reply.Documents)); }
/// <summary> /// Initializes an instance of <see cref="WrappedRsaSecurityTokenAuthenticator"/> /// </summary> /// <param name="sessionTokenHandler">The sessionTokenHandler to wrap</param> /// <param name="wcfSessionAuthenticator">The wcf SessionTokenAuthenticator.</param> /// <param name="sctClaimsHandler">Handler that converts WCF generated IAuthorizationPolicy to <see cref="AuthorizationPolicy"/></param> /// <param name="exceptionMapper">Converts token validation exception to SOAP faults.</param> public WrappedSessionSecurityTokenAuthenticator(SessionSecurityTokenHandler sessionTokenHandler, SecurityTokenAuthenticator wcfSessionAuthenticator, SctClaimsHandler sctClaimsHandler, ExceptionMapper exceptionMapper) : base() { if (sessionTokenHandler == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("sessionTokenHandler"); } if (wcfSessionAuthenticator == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("wcfSessionAuthenticator"); } if (sctClaimsHandler == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("sctClaimsHandler"); } if (exceptionMapper == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("exceptionMapper"); } _issuanceSecurityTokenAuthenticator = wcfSessionAuthenticator as IIssuanceSecurityTokenAuthenticator; if (_issuanceSecurityTokenAuthenticator == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperInvalidOperation(SR.GetString(SR.ID4244)); } _communicationObject = wcfSessionAuthenticator as ICommunicationObject; if (_communicationObject == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperInvalidOperation(SR.GetString(SR.ID4245)); } _sessionTokenHandler = sessionTokenHandler; _sctClaimsHandler = sctClaimsHandler; _exceptionMapper = exceptionMapper; }
public void TestThrowsDuplicateKeyExceptionForMongod(int code) { var response = new BsonDocument { { "ok", 1 }, { "err", string.Format("E{0} duplicate key error index: test.foo.$_id_ dup key: {{ : 1.0 }}", code) }, { "code", code }, { "n", 0 }, { "connectionId", 1 } }; var writeConcernResult = new WriteConcernResult(response); writeConcernResult.ServerInstance = _primary; var ex = ExceptionMapper.Map(writeConcernResult); Assert.IsNotNull(ex); Assert.IsInstanceOf <MongoDuplicateKeyException>(ex); }
public void TestThrowsWriteConcernExceptionWhenOkButHasLastErrorMessage() { var response = new BsonDocument { { "err", "oops" }, { "code", 20 }, { "n", 0 }, { "connectionId", 1 }, { "ok", 1 } }; var writeConcernResult = new WriteConcernResult(response); writeConcernResult.ServerInstance = _primary; var ex = ExceptionMapper.Map(writeConcernResult); Assert.IsNotNull(ex); Assert.IsInstanceOf <WriteConcernException>(ex); }
internal void ShouldInvalidateServer_should_return_expected_result_for_MongoCommandException(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", 0 }, { "code", () => (int)code.Value, code.HasValue }, { "errmsg", message, message != null } }; var exception = ExceptionMapper.MapNotPrimaryOrNodeIsRecovering(connectionId, command, commandResult, "errmsg") ?? new MongoCommandException(connectionId, "message", command, commandResult); // this needs for cases when we have just a random exception var result = _subject.ShouldInvalidateServer(Mock.Of <IConnection>(), exception, new ServerDescription(_subject.ServerId, _subject.EndPoint), out _); result.Should().Be(expectedResult); }
protected WriteConcernResult ReadWriteConcernResult(MongoConnection connection, SendMessageWithWriteConcernResult sendMessageResult) { var writeConcernResultSerializer = BsonSerializer.LookupSerializer(typeof(WriteConcernResult)); var replyMessage = connection.ReceiveMessage <WriteConcernResult>(ReaderSettings, writeConcernResultSerializer, null); if (replyMessage.NumberReturned == 0) { throw new MongoCommandException("Command 'getLastError' failed. No response returned"); } var writeConcernResult = replyMessage.Documents[0]; writeConcernResult.Command = sendMessageResult.GetLastErrorCommand; var mappedException = ExceptionMapper.Map(writeConcernResult); if (mappedException != null) { throw mappedException; } return(writeConcernResult); }
/// <summary> /// If error results exist in the context, maps each error code to a specific exception /// type, then builds and throws a <see cref="MultiStatusException{T}"/>, with specific /// exceptions nested within. /// </summary> /// <typeparam name="T">The type of data entity.</typeparam> /// <param name="context">The object of state through the pipeline.</param> /// <param name="logger">The logging instance.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns>The completed asynchronous task.</returns> protected override Task _ProcessAsync <T>( PipelineContext <T> context, ILogger logger, CancellationToken cancellationToken) { if (context.Results == null || !context.Results.ErrorItems.Any()) { return(Task.CompletedTask); } var exceptions = new List <ApiException>(); foreach (ErrorItem <T> errorItem in context.Results.ErrorItems) { exceptions.Add(ExceptionMapper.Map(errorItem.Code, errorItem.Message, errorItem.Extra)); } throw new MultiStatusException <T>( "One or more items in the batch failed. See inner exception for details.", new AggregateException(exceptions), context.Results); }
public static T GetResponse <T>(this Uri uri, string domainKey, string domainPassword) where T : class { var request = (HttpWebRequest)HttpWebRequest.Create(uri.OriginalString); string encoded = Convert.ToBase64String(Encoding.UTF8.GetBytes(string.Format("{0}:{1}", domainKey, domainPassword))); request.Headers[HttpRequestHeader.Authorization] = string.Format("Basic {0}", encoded); try { using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) { if (response.StatusCode != HttpStatusCode.OK) { throw ExceptionMapper.GetException(response.StatusCode); } using (var stream = new StreamReader(response.GetResponseStream())) { string fullResponse = stream.ReadToEnd(); if (CloudSponge.Format.Equals("json", StringComparison.OrdinalIgnoreCase)) { return(JsonConvert.DeserializeObject <T>(fullResponse)); } else { return(ParseXml <T>(fullResponse)); } } } } catch (Exception ex) { throw ExceptionMapper.GetException(ex.Message); } }
// 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 }
private CursorBatch <TDocument> ProcessReply(ConnectionId connectionId, ReplyMessage <TDocument> reply) { if (reply.QueryFailure) { var response = reply.QueryFailureDocument; var notPrimaryOrNodeIsRecoveringException = ExceptionMapper.MapNotPrimaryOrNodeIsRecovering(connectionId, response, "$err"); if (notPrimaryOrNodeIsRecoveringException != null) { throw notPrimaryOrNodeIsRecoveringException; } var mappedException = ExceptionMapper.Map(connectionId, response); if (mappedException != null) { throw mappedException; } var message = string.Format("QueryFailure flag was true (response was {0}).", response.ToJson()); throw new MongoQueryException(connectionId, message, _query, response); } return(new CursorBatch <TDocument>(reply.CursorId, reply.Documents)); }
public void ExceptionMapper_MapsUnmappedExceptionsAsExpected() { Assert.IsInstanceOfType(ExceptionMapper.Map(999), typeof(UnmappedApiException)); }
public void ExceptionMapper_MapsServerExceptionsAsExpected() { Assert.IsInstanceOfType(ExceptionMapper.Map(500), typeof(InternalServerException)); Assert.IsInstanceOfType(ExceptionMapper.Map(501), typeof(MethodNotImplementedException)); Assert.IsInstanceOfType(ExceptionMapper.Map(503), typeof(ServiceUnavailableException)); }
public override void Given() { ExceptionMapper = new ExceptionMapper(ExceptionExploders, ExceptionMappers); }
// internal methods internal void ReadFrom(BsonBuffer buffer, IBsonSerializationOptions serializationOptions) { if (serializationOptions == null && typeof(TDocument) == typeof(BsonDocument)) { serializationOptions = DocumentSerializationOptions.AllowDuplicateNamesInstance; } var messageStartPosition = buffer.Position; ReadMessageHeaderFrom(buffer); _responseFlags = (ResponseFlags)buffer.ReadInt32(); _cursorId = buffer.ReadInt64(); _startingFrom = buffer.ReadInt32(); _numberReturned = buffer.ReadInt32(); if ((_responseFlags & ResponseFlags.CursorNotFound) != 0) { throw new MongoQueryException("Cursor not found."); } if ((_responseFlags & ResponseFlags.QueryFailure) != 0) { BsonDocument document; using (BsonReader bsonReader = new BsonBinaryReader(buffer, false, _readerSettings)) { document = (BsonDocument)BsonDocumentSerializer.Instance.Deserialize(bsonReader, typeof(BsonDocument), null); } var mappedException = ExceptionMapper.Map(document); if (mappedException != null) { throw mappedException; } var err = document.GetValue("$err", "Unknown error."); var message = string.Format("QueryFailure flag was {0} (response was {1}).", err, document.ToJson()); throw new MongoQueryException(message, document); } _documents = new List <TDocument>(_numberReturned); for (int i = 0; i < _numberReturned; i++) { BsonBuffer sliceBuffer; if (buffer.ByteBuffer is MultiChunkBuffer) { // we can use slightly faster SingleChunkBuffers for all documents that don't span chunk boundaries var position = buffer.Position; var length = buffer.ReadInt32(); var slice = buffer.ByteBuffer.GetSlice(position, length); buffer.Position = position + length; sliceBuffer = new BsonBuffer(slice, true); } else { sliceBuffer = new BsonBuffer(buffer.ByteBuffer, false); } using (var bsonReader = new BsonBinaryReader(sliceBuffer, true, _readerSettings)) { var document = (TDocument)_serializer.Deserialize(bsonReader, typeof(TDocument), serializationOptions); _documents.Add(document); } } }
public override void When() { ActualResult = ExceptionMapper.Map(Input); }
private TCommandResult ProcessReply(ConnectionId connectionId, ReplyMessage <RawBsonDocument> reply) { if (reply.NumberReturned == 0) { throw new MongoCommandException(connectionId, "Command returned no documents.", _command); } if (reply.NumberReturned > 1) { throw new MongoCommandException(connectionId, "Command returned multiple documents.", _command); } if (reply.QueryFailure) { var failureDocument = reply.QueryFailureDocument; throw ExceptionMapper.Map(connectionId, failureDocument) ?? new MongoCommandException(connectionId, "Command failed.", _command, failureDocument); } using (var rawDocument = reply.Documents[0]) { if (!rawDocument.GetValue("ok", false).ToBoolean()) { var binaryReaderSettings = new BsonBinaryReaderSettings(); if (_messageEncoderSettings != null) { binaryReaderSettings.Encoding = _messageEncoderSettings.GetOrDefault <UTF8Encoding>(MessageEncoderSettingsName.ReadEncoding, Utf8Encodings.Strict); binaryReaderSettings.GuidRepresentation = _messageEncoderSettings.GetOrDefault <GuidRepresentation>(MessageEncoderSettingsName.GuidRepresentation, GuidRepresentation.CSharpLegacy); } ; var materializedDocument = rawDocument.Materialize(binaryReaderSettings); var commandName = _command.GetElement(0).Name; if (commandName == "$query") { commandName = _command["$query"].AsBsonDocument.GetElement(0).Name; } var notPrimaryOrNodeIsRecoveringException = ExceptionMapper.MapNotPrimaryOrNodeIsRecovering(connectionId, materializedDocument, "errmsg"); if (notPrimaryOrNodeIsRecoveringException != null) { throw notPrimaryOrNodeIsRecoveringException; } string message; BsonValue errmsgBsonValue; if (materializedDocument.TryGetValue("errmsg", out errmsgBsonValue) && errmsgBsonValue.IsString) { var errmsg = errmsgBsonValue.ToString(); message = string.Format("Command {0} failed: {1}.", commandName, errmsg); } else { message = string.Format("Command {0} failed.", commandName); } var mappedException = ExceptionMapper.Map(connectionId, materializedDocument); if (mappedException != null) { throw mappedException; } throw new MongoCommandException(connectionId, message, _command, materializedDocument); } using (var stream = new ByteBufferStream(rawDocument.Slice, ownsBuffer: false)) { var encoderFactory = new BinaryMessageEncoderFactory(stream, _messageEncoderSettings); var encoder = (ReplyMessageBinaryEncoder <TCommandResult>)encoderFactory.GetReplyMessageEncoder <TCommandResult>(_resultSerializer); using (var reader = encoder.CreateBinaryReader()) { var context = BsonDeserializationContext.CreateRoot(reader); return(_resultSerializer.Deserialize(context)); } } } }
private TCommandResult ProcessReply(ConnectionId connectionId, ReplyMessage <RawBsonDocument> reply) { if (reply.NumberReturned == 0) { throw new MongoCommandException(connectionId, "Command returned no documents.", _command); } if (reply.NumberReturned > 1) { throw new MongoCommandException(connectionId, "Command returned multiple documents.", _command); } if (reply.QueryFailure) { var failureDocument = reply.QueryFailureDocument; throw ExceptionMapper.Map(connectionId, failureDocument) ?? new MongoCommandException(connectionId, "Command failed.", _command, failureDocument); } using (var rawDocument = reply.Documents[0]) { var binaryReaderSettings = new BsonBinaryReaderSettings(); if (_messageEncoderSettings != null) { binaryReaderSettings.Encoding = _messageEncoderSettings.GetOrDefault <UTF8Encoding>(MessageEncoderSettingsName.ReadEncoding, Utf8Encodings.Strict); #pragma warning disable 618 if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2) { binaryReaderSettings.GuidRepresentation = _messageEncoderSettings.GetOrDefault <GuidRepresentation>(MessageEncoderSettingsName.GuidRepresentation, GuidRepresentation.CSharpLegacy); } #pragma warning restore 618 } ; BsonValue clusterTime; if (rawDocument.TryGetValue("$clusterTime", out clusterTime)) { // note: we are assuming that _session is an instance of ClusterClockAdvancingClusterTime // and that calling _session.AdvanceClusterTime will have the side effect of advancing the cluster's ClusterTime also var materializedClusterTime = ((RawBsonDocument)clusterTime).Materialize(binaryReaderSettings); _session.AdvanceClusterTime(materializedClusterTime); } BsonValue operationTime; if (rawDocument.TryGetValue("operationTime", out operationTime)) { _session.AdvanceOperationTime(operationTime.AsBsonTimestamp); } if (!rawDocument.GetValue("ok", false).ToBoolean()) { var materializedDocument = rawDocument.Materialize(binaryReaderSettings); var commandName = _command.GetElement(0).Name; if (commandName == "$query") { commandName = _command["$query"].AsBsonDocument.GetElement(0).Name; } var notPrimaryOrNodeIsRecoveringException = ExceptionMapper.MapNotPrimaryOrNodeIsRecovering(connectionId, _command, materializedDocument, "errmsg"); if (notPrimaryOrNodeIsRecoveringException != null) { throw notPrimaryOrNodeIsRecoveringException; } string message; BsonValue errmsgBsonValue; if (materializedDocument.TryGetValue("errmsg", out errmsgBsonValue) && errmsgBsonValue.IsString) { var errmsg = errmsgBsonValue.ToString(); message = string.Format("Command {0} failed: {1}.", commandName, errmsg); } else { message = string.Format("Command {0} failed.", commandName); } var mappedException = ExceptionMapper.Map(connectionId, materializedDocument); if (mappedException != null) { throw mappedException; } throw new MongoCommandException(connectionId, message, _command, materializedDocument); } if (rawDocument.Contains("writeConcernError")) { var materializedDocument = rawDocument.Materialize(binaryReaderSettings); var writeConcernError = materializedDocument["writeConcernError"].AsBsonDocument; var message = writeConcernError.AsBsonDocument.GetValue("errmsg", null)?.AsString; var writeConcernResult = new WriteConcernResult(materializedDocument); throw new MongoWriteConcernException(connectionId, message, writeConcernResult); } using (var stream = new ByteBufferStream(rawDocument.Slice, ownsBuffer: false)) { var encoderFactory = new BinaryMessageEncoderFactory(stream, _messageEncoderSettings); var encoder = (ReplyMessageBinaryEncoder <TCommandResult>)encoderFactory.GetReplyMessageEncoder <TCommandResult>(_resultSerializer); using (var reader = encoder.CreateBinaryReader()) { var context = BsonDeserializationContext.CreateRoot(reader); return(_resultSerializer.Deserialize(context)); } } } }
private void ApplyApplicationError(BsonDocument applicationError) { var expectedKeys = new[] { "address", "generation", // optional "maxWireVersion", "when", "type", "response" // optional }; JsonDrivenHelper.EnsureAllFieldsAreValid(applicationError, expectedKeys); var address = applicationError["address"].AsString; var endPoint = EndPointHelper.Parse(address); var server = (Server)_serverFactory.GetServer(endPoint); var connectionId = new ConnectionId(server.ServerId); var type = applicationError["type"].AsString; var maxWireVersion = applicationError["maxWireVersion"].AsInt32; Exception simulatedException = null; switch (type) { case "command": var response = applicationError["response"].AsBsonDocument; var command = new BsonDocument("Link", "start!"); simulatedException = ExceptionMapper.MapNotPrimaryOrNodeIsRecovering(connectionId, command, response, "errmsg"); Ensure.IsNotNull(simulatedException, nameof(simulatedException)); break; case "network": { var innerException = CoreExceptionHelper.CreateException("IOExceptionWithNetworkUnreachableSocketException"); simulatedException = new MongoConnectionException(connectionId, "Ignorance, yet knowledge.", innerException); break; } case "timeout": { var innerException = CoreExceptionHelper.CreateException("IOExceptionWithTimedOutSocketException"); simulatedException = new MongoConnectionException(connectionId, "Chaos, yet harmony.", innerException); break; } default: throw new ArgumentException($"Unsupported value of {type} for type"); } var mockConnection = new Mock <IConnectionHandle>(); var isMasterResult = new IsMasterResult(new BsonDocument { { "compressors", new BsonArray() } }); var serverVersion = WireVersionHelper.MapWireVersionToServerVersion(maxWireVersion); var buildInfoResult = new BuildInfoResult(new BsonDocument { { "version", serverVersion } }); mockConnection.SetupGet(c => c.Description) .Returns(new ConnectionDescription(connectionId, isMasterResult, buildInfoResult)); var generation = applicationError.Contains("generation") ? applicationError["generation"].AsInt32 : 0; mockConnection.SetupGet(c => c.Generation).Returns(generation); var when = applicationError["when"].AsString; switch (when) { case "beforeHandshakeCompletes": server.HandleBeforeHandshakeCompletesException(mockConnection.Object, simulatedException); break; case "afterHandshakeCompletes": server.HandleChannelException(mockConnection.Object, simulatedException); break; default: throw new ArgumentException($"Unsupported value of {when} for when."); } }
private TCommandResult ProcessResponse(ConnectionId connectionId, CommandMessage responseMessage) { using (new CommandMessageDisposer(responseMessage)) { var rawDocument = responseMessage.Sections.OfType <Type0CommandMessageSection <RawBsonDocument> >().Single().Document; var binaryReaderSettings = new BsonBinaryReaderSettings(); if (_messageEncoderSettings != null) { binaryReaderSettings.Encoding = _messageEncoderSettings.GetOrDefault <UTF8Encoding>(MessageEncoderSettingsName.ReadEncoding, Utf8Encodings.Strict); binaryReaderSettings.GuidRepresentation = _messageEncoderSettings.GetOrDefault <GuidRepresentation>(MessageEncoderSettingsName.GuidRepresentation, GuidRepresentation.CSharpLegacy); } ; BsonValue clusterTime; if (rawDocument.TryGetValue("$clusterTime", out clusterTime)) { // note: we are assuming that _session is an instance of ClusterClockAdvancingClusterTime // and that calling _session.AdvanceClusterTime will have the side effect of advancing the cluster's ClusterTime also var materializedClusterTime = ((RawBsonDocument)clusterTime).Materialize(binaryReaderSettings); _session.AdvanceClusterTime(materializedClusterTime); } BsonValue operationTime; if (rawDocument.TryGetValue("operationTime", out operationTime)) { _session.AdvanceOperationTime(operationTime.AsBsonTimestamp); } if (!rawDocument.GetValue("ok", false).ToBoolean()) { var materializedDocument = rawDocument.Materialize(binaryReaderSettings); var commandName = _command.GetElement(0).Name; if (commandName == "$query") { commandName = _command["$query"].AsBsonDocument.GetElement(0).Name; } var notPrimaryOrNodeIsRecoveringException = ExceptionMapper.MapNotPrimaryOrNodeIsRecovering(connectionId, materializedDocument, "errmsg"); if (notPrimaryOrNodeIsRecoveringException != null) { throw notPrimaryOrNodeIsRecoveringException; } var mappedException = ExceptionMapper.Map(connectionId, materializedDocument); if (mappedException != null) { throw mappedException; } string message; BsonValue errmsgBsonValue; if (materializedDocument.TryGetValue("errmsg", out errmsgBsonValue) && errmsgBsonValue.IsString) { var errmsg = errmsgBsonValue.ToString(); message = string.Format("Command {0} failed: {1}.", commandName, errmsg); } else { message = string.Format("Command {0} failed.", commandName); } throw new MongoCommandException(connectionId, message, _command, materializedDocument); } using (var stream = new ByteBufferStream(rawDocument.Slice, ownsBuffer: false)) { using (var reader = new BsonBinaryReader(stream, binaryReaderSettings)) { var context = BsonDeserializationContext.CreateRoot(reader); return(_resultSerializer.Deserialize(context)); } } } }
private TCommandResult ProcessResponse(ConnectionId connectionId, CommandMessage responseMessage) { using (new CommandMessageDisposer(responseMessage)) { var rawDocument = responseMessage.Sections.OfType <Type0CommandMessageSection <RawBsonDocument> >().Single().Document; var binaryReaderSettings = new BsonBinaryReaderSettings(); if (_messageEncoderSettings != null) { binaryReaderSettings.Encoding = _messageEncoderSettings.GetOrDefault <UTF8Encoding>(MessageEncoderSettingsName.ReadEncoding, Utf8Encodings.Strict); #pragma warning disable 618 if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2) { binaryReaderSettings.GuidRepresentation = _messageEncoderSettings.GetOrDefault <GuidRepresentation>(MessageEncoderSettingsName.GuidRepresentation, GuidRepresentation.CSharpLegacy); } #pragma warning restore 618 } ; BsonValue clusterTime; if (rawDocument.TryGetValue("$clusterTime", out clusterTime)) { // note: we are assuming that _session is an instance of ClusterClockAdvancingClusterTime // and that calling _session.AdvanceClusterTime will have the side effect of advancing the cluster's ClusterTime also var materializedClusterTime = ((RawBsonDocument)clusterTime).Materialize(binaryReaderSettings); _session.AdvanceClusterTime(materializedClusterTime); } BsonValue operationTime; if (rawDocument.TryGetValue("operationTime", out operationTime)) { _session.AdvanceOperationTime(operationTime.AsBsonTimestamp); } if (rawDocument.GetValue("ok", false).ToBoolean()) { if (rawDocument.TryGetValue("recoveryToken", out var rawRecoveryToken)) { var recoveryToken = ((RawBsonDocument)rawRecoveryToken).Materialize(binaryReaderSettings); _session.CurrentTransaction.RecoveryToken = recoveryToken; } } else { var materializedDocument = rawDocument.Materialize(binaryReaderSettings); var commandName = _command.GetElement(0).Name; if (commandName == "$query") { commandName = _command["$query"].AsBsonDocument.GetElement(0).Name; } var notPrimaryOrNodeIsRecoveringException = ExceptionMapper.MapNotPrimaryOrNodeIsRecovering(connectionId, _command, materializedDocument, "errmsg"); if (notPrimaryOrNodeIsRecoveringException != null) { throw notPrimaryOrNodeIsRecoveringException; } var mappedException = ExceptionMapper.Map(connectionId, materializedDocument); if (mappedException != null) { throw mappedException; } string message; BsonValue errmsgBsonValue; if (materializedDocument.TryGetValue("errmsg", out errmsgBsonValue) && errmsgBsonValue.IsString) { var errmsg = errmsgBsonValue.ToString(); message = string.Format("Command {0} failed: {1}.", commandName, errmsg); } else { message = string.Format("Command {0} failed.", commandName); } var exception = new MongoCommandException(connectionId, message, _command, materializedDocument); // https://jira.mongodb.org/browse/CSHARP-2678 if (IsRetryableWriteExceptionAndDeploymentDoesNotSupportRetryableWrites(exception)) { throw WrapNotSupportedRetryableWriteException(exception); } else { throw exception; } } if (rawDocument.Contains("writeConcernError")) { var materializedDocument = rawDocument.Materialize(binaryReaderSettings); var writeConcernError = materializedDocument["writeConcernError"].AsBsonDocument; var message = writeConcernError.AsBsonDocument.GetValue("errmsg", null)?.AsString; var writeConcernResult = new WriteConcernResult(materializedDocument); throw new MongoWriteConcernException(connectionId, message, writeConcernResult); } using (var stream = new ByteBufferStream(rawDocument.Slice, ownsBuffer: false)) { using (var reader = new BsonBinaryReader(stream, binaryReaderSettings)) { var context = BsonDeserializationContext.CreateRoot(reader); return(_resultSerializer.Deserialize(context)); } } } }