internal WriteResult WriteMessageTakingWriteLockSync(PhysicalConnection physical, Message message) { Trace("Writing: " + message); message.SetEnqueued(physical); // this also records the read/write stats at this point try { using (var token = _singleWriterMutex.TryWait()) { if (!token.Success) { message.Cancel(); Multiplexer?.OnMessageFaulted(message, null); this.CompleteSyncOrAsync(message); return(WriteResult.TimeoutBeforeWrite); } var result = WriteMessageInsideLock(physical, message); if (result == WriteResult.Success) { #pragma warning disable CS0618 result = physical.FlushSync(false, TimeoutMilliseconds); #pragma warning restore CS0618 } UnmarkActiveMessage(message); physical.SetIdle(); return(result); } } catch (Exception ex) { return(HandleWriteException(message, ex)); } }
internal WriteResult WriteMessageTakingWriteLockSync(PhysicalConnection physical, Message message) { Trace("Writing: " + message); message.SetEnqueued(physical); // this also records the read/write stats at this point LockToken token = default; try { token = _singleWriterMutex.TryWait(WaitOptions.NoDelay); if (!token.Success) { // we can't get it *instantaneously*; is there // perhaps a backlog and active backlog processor? bool haveBacklog; lock (_backlog) { haveBacklog = _backlog.Count != 0; } if (haveBacklog) { PushToBacklog(message); return(WriteResult.Success); // queued counts as success } // no backlog... try to wait with the timeout; // if we *still* can't get it: that counts as // an actual timeout token = _singleWriterMutex.TryWait(); if (!token.Success) { message.Cancel(); Multiplexer?.OnMessageFaulted(message, null); message.Complete(); return(WriteResult.TimeoutBeforeWrite); } } var result = WriteMessageInsideLock(physical, message); if (result == WriteResult.Success) { #pragma warning disable CS0618 result = physical.FlushSync(false, TimeoutMilliseconds); #pragma warning restore CS0618 } UnmarkActiveMessage(message); physical.SetIdle(); return(result); } catch (Exception ex) { return(HandleWriteException(message, ex)); } finally { token.Dispose(); } }
internal WriteResult WriteMessageTakingWriteLockSync(PhysicalConnection physical, Message message) { Trace("Writing: " + message); message.SetEnqueued(physical); // this also records the read/write stats at this point bool haveLock = false; try { haveLock = _SingleWriterLock.Wait(TimeoutMilliseconds); if (!haveLock) { message.Cancel(); Multiplexer?.OnMessageFaulted(message, null); this.CompleteSyncOrAsync(message); return(WriteResult.TimeoutBeforeWrite); } var result = WriteMessageInsideLock(physical, message); if (result == WriteResult.Success) { #pragma warning disable CS0618 result = physical.FlushSync(false, TimeoutMilliseconds); #pragma warning restore CS0618 } physical.SetIdle(); return(result); } catch (Exception ex) { return(HandleWriteException(message, ex)); } finally { if (haveLock) { ReleaseSingleWriterLock(message); } } }
private void ProcessBacklog() { LockToken token = default; try { while (true) { // try and get the lock; if unsuccessful, check for termination token = _singleWriterMutex.TryWait(); if (token) { break; // got the lock } lock (_backlog) { if (_backlog.Count == 0) { return; } } } // so now we are the writer; write some things! Message message; var timeout = TimeoutMilliseconds; while (true) { lock (_backlog) { if (_backlog.Count == 0) { break; // all done } message = _backlog.Dequeue(); } try { if (message.HasAsyncTimedOut(Environment.TickCount, timeout, out var elapsed)) { var ex = Multiplexer.GetException(WriteResult.TimeoutBeforeWrite, message, ServerEndPoint); message.SetExceptionAndComplete(ex, this); } else { var result = WriteMessageInsideLock(physical, message); if (result == WriteResult.Success) { #pragma warning disable CS0618 result = physical.FlushSync(false, timeout); #pragma warning restore CS0618 } UnmarkActiveMessage(message); if (result != WriteResult.Success) { var ex = Multiplexer.GetException(result, message, ServerEndPoint); HandleWriteException(message, ex); } } } catch (Exception ex) { HandleWriteException(message, ex); } } physical.SetIdle(); } finally { token.Dispose(); } }
/// <summary> /// This writes a message to the output stream /// </summary> /// <param name="physical">The phsyical connection to write to.</param> /// <param name="message">The message to be written.</param> internal WriteResult WriteMessageTakingWriteLock(PhysicalConnection physical, Message message) { Trace("Writing: " + message); message.SetEnqueued(); WriteResult result; bool haveLock = false; try { Monitor.TryEnter(SingleWriterLock, TimeoutMilliseconds, ref haveLock); if (!haveLock) { message.Cancel(); Multiplexer?.OnMessageFaulted(message, null); this.CompleteSyncOrAsync(message); return(WriteResult.TimeoutBeforeWrite); } var existingMessage = Interlocked.CompareExchange(ref _activeMesssage, message, null); if (existingMessage != null) { Multiplexer?.OnInfoMessage($"reentrant call to WriteMessageTakingWriteLock for {message.CommandAndKey}, {existingMessage.CommandAndKey} is still active"); return(WriteResult.NoConnectionAvailable); } physical.SetWriting(); var messageIsSent = false; if (message is IMultiMessage) { SelectDatabaseInsideWriteLock(physical, message); // need to switch database *before* the transaction foreach (var subCommand in ((IMultiMessage)message).GetMessages(physical)) { result = WriteMessageToServerInsideWriteLock(physical, subCommand); if (result != WriteResult.Success) { // we screwed up; abort; note that WriteMessageToServer already // killed the underlying connection Trace("Unable to write to server"); message.Fail(ConnectionFailureType.ProtocolFailure, null, "failure before write: " + result.ToString()); this.CompleteSyncOrAsync(message); return(result); } //The parent message (next) may be returned from GetMessages //and should not be marked as sent again below messageIsSent = messageIsSent || subCommand == message; } if (!messageIsSent) { message.SetRequestSent(); // well, it was attempted, at least... } result = WriteResult.Success; } else { result = WriteMessageToServerInsideWriteLock(physical, message); } if (result == WriteResult.Success) { result = physical.FlushSync(); } physical.SetIdle(); } catch (Exception ex) { var inner = new RedisConnectionException(ConnectionFailureType.InternalFailure, "Failed to write", ex); message.SetExceptionAndComplete(inner, this); result = WriteResult.WriteFailure; } finally { if (haveLock) { Interlocked.CompareExchange(ref _activeMesssage, null, message); // remove if it is us Monitor.Exit(SingleWriterLock); } } return(result); }