private void ProcessInput(QueuedBlockMsg dataMsg)
{
dataMsg.GetMessageSize();
if (this.m_newestMessage != null)
{
this.m_newestMessage.NextMsg = dataMsg;
this.m_newestMessage = dataMsg;
}
else
{
this.m_newestMessage = dataMsg;
this.m_oldestMessage = dataMsg;
}
bool flag = BitMasker.IsOn((int)dataMsg.EmitContext.grbitOperationalFlags, 16);
if (PassiveBlockMode.IsDebugTraceEnabled)
{
long num = StopwatchStamp.TicksToMicroSeconds(dataMsg.ReadDurationInTics);
PassiveBlockMode.Tracer.TraceDebug((long)this.GetHashCode(), "MessageArrived({0}) Gen=0x{1:X} Sector=0x{2:X} JBits=0x{3:X} EmitSeq=0x{4:X} LogDataLen=0x{5:X} ReadUSec={6}", new object[]
{
this.DatabaseName,
dataMsg.EmitContext.lgposLogData.lGeneration,
dataMsg.EmitContext.lgposLogData.isec,
(int)dataMsg.EmitContext.grbitOperationalFlags,
dataMsg.EmitContext.qwSequenceNum,
dataMsg.LogDataLength,
num
});
}
this.Copier.PerfmonCounters.RecordGranularBytesReceived((long)dataMsg.LogDataLength, flag);
ExchangeNetworkPerfmonCounters perfCounters = this.m_netChannel.PerfCounters;
if (perfCounters != null)
{
perfCounters.RecordLogCopyThruputReceived((long)dataMsg.LogDataLength);
if (dataMsg.CompressedLogDataLength > 0)
{
perfCounters.RecordCompressedDataReceived(dataMsg.CompressedLogDataLength, dataMsg.LogDataLength, NetworkPath.ConnectionPurpose.LogCopy);
}
}
this.TriggerConsumer();
if (flag || DateTime.UtcNow >= this.m_nextPingDue)
{
uint lGeneration = (uint)dataMsg.EmitContext.lgposLogData.lGeneration;
if (flag)
{
this.Copier.TrackKnownEndOfLog((long)((ulong)lGeneration), dataMsg.EmitContext.logtimeEmit);
}
NetworkTransportException ex;
bool flag2;
this.TrySendStatusMessageToActive(flag ? PassiveStatusMsg.Flags.AckEndOfGeneration : PassiveStatusMsg.Flags.None, dataMsg.RequestAckCounter, out ex, out flag2);
if (ex != null)
{
throw ex;
}
}
}
public override void Write(byte[] buffer, int offset, int size)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (offset < 0 || offset > buffer.Length)
{
throw new ArgumentOutOfRangeException("offset");
}
if (size < 0 || size > buffer.Length - offset)
{
throw new ArgumentOutOfRangeException("size");
}
Socket socket = this.Socket;
if (socket == null)
{
throw new IOException("net_io_writefailure:nosocket");
}
try
{
StopwatchStamp stamp = StopwatchStamp.GetStamp();
socket.Send(buffer, offset, size, SocketFlags.None);
if (this.m_perfCounters != null)
{
this.m_perfCounters.RecordWriteLatency(stamp.ElapsedTicks);
}
}
catch (Exception ex)
{
if (ex is ThreadAbortException || ex is StackOverflowException || ex is OutOfMemoryException)
{
throw;
}
throw new IOException(string.Format("net_io_writefailure: {0}", ex.Message), ex);
}
}
private QueuedBlockMsg ReadInputMessage(NetworkChannel netChan)
{
this.m_timeoutPending = false;
byte[] networkReadWorkingBuf = this.m_networkReadWorkingBuf;
StopwatchStamp stamp = StopwatchStamp.GetStamp();
NetworkChannelMessageHeader msgHdr = NetworkChannelMessage.ReadHeaderFromNet(netChan, networkReadWorkingBuf, 0);
NetworkChannelMessage.MessageType messageType = msgHdr.MessageType;
QueuedBlockMsg queuedBlockMsg;
if (messageType != NetworkChannelMessage.MessageType.BlockModeCompressedData)
{
if (messageType == NetworkChannelMessage.MessageType.Ping)
{
PingMessage pingMessage = PingMessage.ReadFromNet(netChan, networkReadWorkingBuf, 0);
long systemPerformanceCounter = Win32StopWatch.GetSystemPerformanceCounter();
long arg = Win32StopWatch.ComputeElapsedTimeInUSec(systemPerformanceCounter, pingMessage.ReplyAckCounter) / 1000L;
this.Copier.TrackLastContactTime(msgHdr.MessageUtc);
PassiveBlockMode.Tracer.TraceDebug <string, long>((long)this.GetHashCode(), "ProcessReadCallback({0}) received a ping after {1}ms, so channel is healthy", this.DatabaseName, arg);
return(null);
}
if (messageType != NetworkChannelMessage.MessageType.GranularLogData)
{
throw new NetworkUnexpectedMessageException(netChan.PartnerNodeName, string.Format("Unknown Type {0}", msgHdr.MessageType));
}
queuedBlockMsg = this.ReadUncompressedMsg(netChan);
this.Copier.PerfmonCounters.CompressionEnabled = 0L;
}
else
{
queuedBlockMsg = this.ReadCompressedMsg(netChan, msgHdr);
this.Copier.PerfmonCounters.CompressionEnabled = 1L;
}
queuedBlockMsg.ReadDurationInTics = stamp.ElapsedTicks;
queuedBlockMsg.MessageUtc = msgHdr.MessageUtc;
this.Copier.PerfmonCounters.RecordLogCopierNetworkReadLatency(queuedBlockMsg.ReadDurationInTics);
return(queuedBlockMsg);
}
public void Write(JET_EMITDATACTX emitCtx, byte[] databuf, int startOffset)
{
if (!this.m_jetConsumerInitialized)
{
throw new GranularReplicationTerminatedException("Already terminated");
}
try
{
StopwatchStamp stamp = StopwatchStamp.GetStamp();
long num = (long)emitCtx.lgposLogData.lGeneration;
int grbitOperationalFlags = (int)emitCtx.grbitOperationalFlags;
bool flag = false;
if (BitMasker.IsOn(grbitOperationalFlags, 16))
{
flag = true;
}
UnpublishedApi.JetConsumeLogData(this.m_jetConsumer, emitCtx, databuf, startOffset, (int)emitCtx.cbLogData, ShadowLogConsumeGrbit.FlushData);
if (flag)
{
GranularWriter.Tracer.TraceDebug <string, long>((long)this.GetHashCode(), "WriteGranular({0}): 0x{1:X} is complete", this.DatabaseName, num);
if (this.m_lowestClosedGeneration == 0L)
{
this.m_lowestClosedGeneration = num;
}
string text = this.FormFullGranuleName(num);
FileInfo fileInfo = new FileInfo(text);
fileInfo.LastWriteTimeUtc = emitCtx.logtimeEmit;
if (this.m_granularCompletionsDisabled)
{
string destFileName = this.FormInspectorLogfileName(num);
File.Move(text, destFileName);
this.TrackInspectorGeneration(num, emitCtx.logtimeEmit);
this.m_lowestClosedGeneration = num + 1L;
}
this.m_currentGenerationState = GranularWriter.GranularLogState.Expected;
this.m_currentGeneration = num + 1L;
}
else if (BitMasker.IsOn(grbitOperationalFlags, 8))
{
this.m_currentGenerationState = GranularWriter.GranularLogState.Open;
this.m_currentGeneration = num;
this.m_lastTimeFromServer = new DateTime?(emitCtx.logtimeEmit);
}
long elapsedTicks = stamp.ElapsedTicks;
this.m_perfmonCounters.RecordBlockModeConsumerWriteLatency(elapsedTicks);
GranularWriter.Tracer.TracePerformance((long)this.GetHashCode(), "WriteGranular({0},0x{1:X}.0x{2:X}) EmitSeq=0x{3:X} took {4} uSec", new object[]
{
this.DatabaseName,
emitCtx.lgposLogData.lGeneration,
emitCtx.lgposLogData.isec,
emitCtx.qwSequenceNum,
StopwatchStamp.TicksToMicroSeconds(elapsedTicks)
});
}
catch (EsentErrorException ex)
{
GranularWriter.Tracer.TraceError <EsentErrorException>((long)this.GetHashCode(), "JetConsumeLogData threw {0}", ex);
this.m_jetConsumerHealthy = false;
throw new GranularReplicationTerminatedException(ex.Message, ex);
}
catch (IOException ex2)
{
GranularWriter.Tracer.TraceError <IOException>((long)this.GetHashCode(), "IOException: {0}", ex2);
this.m_jetConsumerHealthy = false;
throw new GranularReplicationTerminatedException(ex2.Message, ex2);
}
}
