// Token: 0x0600224C RID: 8780 RVA: 0x000A012C File Offset: 0x0009E32C
        public override long GetE00Generation()
        {
            long num = 0L;

            this.GetChannelLock();
            try
            {
                this.OpenChannelIfFirstRequest();
                GetE00GenerationRequest msg = new GetE00GenerationRequest(this.m_channel, this.DatabaseGuid);
                this.SendMessage(msg);
                NetworkChannelMessage reply = this.GetReply();
                GetE00GenerationReply getE00GenerationReply = reply as GetE00GenerationReply;
                if (getE00GenerationReply == null)
                {
                    this.m_channel.ThrowUnexpectedMessage(reply);
                }
                num = getE00GenerationReply.LogGeneration;
                ExTraceGlobals.LogCopyClientTracer.TraceDebug <long>((long)this.GetHashCode(), "LogCopyClient:GetE00Gen: 0x{0:x}", num);
            }
            finally
            {
                this.ReleaseChannelLock();
            }
            return(num);
        }
Esempio n. 2
0
        // Token: 0x06000B8F RID: 2959 RVA: 0x000332C8 File Offset: 0x000314C8
        public void ForceNewLog()
        {
            ExTraceGlobals.IncrementalReseederTracer.TraceDebug((long)this.GetHashCode(), "rolling a log file");
            Exception ex = null;

            try
            {
                this.GetChannel();
                SeedPageReaderRollLogFileRequest seedPageReaderRollLogFileRequest = new SeedPageReaderRollLogFileRequest(this.m_channel, this.m_databaseGuid, this.m_databaseName, this.m_databasePath);
                seedPageReaderRollLogFileRequest.Send();
                NetworkChannelMessage message = this.m_channel.GetMessage();
                if (!(message is SeedPageReaderRollLogFileReply))
                {
                    this.m_channel.ThrowUnexpectedMessage(message);
                }
            }
            catch (NetworkRemoteException ex2)
            {
                ex = ex2;
            }
            catch (NetworkTransportException ex3)
            {
                ex = ex3;
            }
            if (ex != null)
            {
                ReplayEventLogConstants.Tuple_ForceNewLogError.LogEvent(string.Empty, new object[]
                {
                    this.m_databaseName,
                    this.m_serverName,
                    ex
                });
                throw ex;
            }
        }
        // Token: 0x06002249 RID: 8777 RVA: 0x0009FDB0 File Offset: 0x0009DFB0
        public override long QueryEndOfLog()
        {
            long num = -1L;

            this.GetChannelLock();
            try
            {
                this.OpenChannelIfFirstRequest();
                NotifyEndOfLogRequest msg = new NotifyEndOfLogRequest(this.m_channel, this.DatabaseGuid, 0L);
                this.SendMessage(msg);
                NetworkChannelMessage reply = this.GetReply();
                NotifyEndOfLogReply   notifyEndOfLogReply = reply as NotifyEndOfLogReply;
                if (notifyEndOfLogReply == null)
                {
                    this.m_channel.ThrowUnexpectedMessage(reply);
                }
                this.m_endOfLog.SetValue(notifyEndOfLogReply.EndOfLogGeneration, new DateTime?(notifyEndOfLogReply.EndOfLogUtc));
                num = notifyEndOfLogReply.EndOfLogGeneration;
            }
            finally
            {
                this.ReleaseChannelLock();
            }
            ExTraceGlobals.LogCopyClientTracer.TraceDebug <long>((long)this.GetHashCode(), "LogCopyClient:QueryEndOfLog: 0x{0:x}", num);
            return(num);
        }
Esempio n. 4
0
        // Token: 0x06000B94 RID: 2964 RVA: 0x000337D0 File Offset: 0x000319D0
        public byte[] ReadNextPage(long expectedPageNum, out long lowGen, out long highGen)
        {
            if (expectedPageNum < 1L)
            {
                throw new ArgumentOutOfRangeException(string.Format(CultureInfo.CurrentCulture, "pageNumber is {0}, must be >= 1 ", new object[]
                {
                    expectedPageNum
                }));
            }
            lowGen  = (long)((ulong)-1);
            highGen = 0L;
            NetworkChannelMessage         message = this.m_channel.GetMessage();
            SeedPageReaderSinglePageReply seedPageReaderSinglePageReply = message as SeedPageReaderSinglePageReply;

            if (seedPageReaderSinglePageReply == null)
            {
                this.m_channel.ThrowUnexpectedMessage(message);
            }
            if (seedPageReaderSinglePageReply.PageNumber != expectedPageNum)
            {
                this.m_channel.ThrowUnexpectedMessage(message);
            }
            lowGen  = seedPageReaderSinglePageReply.LowGeneration;
            highGen = seedPageReaderSinglePageReply.HighGeneration;
            return(seedPageReaderSinglePageReply.PageBytes);
        }
        // Token: 0x0600224D RID: 8781 RVA: 0x000A01B8 File Offset: 0x0009E3B8
        public override bool LogExists(long logNum)
        {
            bool flag = false;

            this.GetChannelLock();
            try
            {
                this.OpenChannelIfFirstRequest();
                TestLogExistenceRequest msg = new TestLogExistenceRequest(this.m_channel, this.DatabaseGuid, logNum);
                this.SendMessage(msg);
                NetworkChannelMessage reply = this.GetReply();
                TestLogExistenceReply testLogExistenceReply = reply as TestLogExistenceReply;
                if (testLogExistenceReply == null)
                {
                    this.m_channel.ThrowUnexpectedMessage(reply);
                }
                flag = testLogExistenceReply.LogExists;
                ExTraceGlobals.LogCopyClientTracer.TraceDebug <long, bool>((long)this.GetHashCode(), "LogCopyClient:LogExists(0x{0:x})={1}", logNum, flag);
            }
            finally
            {
                this.ReleaseChannelLock();
            }
            return(flag);
        }
Esempio n. 6
0
 // Token: 0x06000B91 RID: 2961 RVA: 0x0003348C File Offset: 0x0003168C
 public byte[] ReadOnePage(long pageNumber, out long lowGen, out long highGen)
 {
     byte[] result = null;
     if (pageNumber < 1L)
     {
         throw new ArgumentOutOfRangeException(string.Format(CultureInfo.CurrentCulture, "pageNumber is {0}, must be >= 1 ", new object[]
         {
             pageNumber
         }));
     }
     lowGen  = (long)((ulong)-1);
     highGen = 0L;
     try
     {
         this.GetChannel();
         SeedPageReaderSinglePageRequest seedPageReaderSinglePageRequest = new SeedPageReaderSinglePageRequest(this.m_channel, this.m_databaseGuid, this.m_databaseName, this.m_databasePath, (uint)pageNumber);
         seedPageReaderSinglePageRequest.Send();
         NetworkChannelMessage         message = this.m_channel.GetMessage();
         SeedPageReaderSinglePageReply seedPageReaderSinglePageReply = message as SeedPageReaderSinglePageReply;
         if (seedPageReaderSinglePageReply == null)
         {
             this.m_channel.ThrowUnexpectedMessage(message);
         }
         this.m_pageSize = (long)seedPageReaderSinglePageReply.PageBytes.Length;
         lowGen          = seedPageReaderSinglePageReply.LowGeneration;
         highGen         = seedPageReaderSinglePageReply.HighGeneration;
         result          = seedPageReaderSinglePageReply.PageBytes;
     }
     catch (NetworkRemoteException ex)
     {
         ReplayEventLogConstants.Tuple_ReadOnePageError.LogEvent(string.Empty, new object[]
         {
             pageNumber,
             this.m_databaseName,
             this.m_serverName,
             ex
         });
         throw;
     }
     catch (NetworkTransportException ex2)
     {
         ReplayEventLogConstants.Tuple_ReadOnePageError.LogEvent(string.Empty, new object[]
         {
             pageNumber,
             this.m_databaseName,
             this.m_serverName,
             ex2
         });
         throw;
     }
     return(result);
 }
Esempio n. 7
0
        // Token: 0x060019CC RID: 6604 RVA: 0x0006BFC4 File Offset: 0x0006A1C4
        private void UpdateProgress(string seedingHandle, IReplicaSeederCallback callback)
        {
            ReplayStopwatch       replayStopwatch       = new ReplayStopwatch();
            ProgressCiFileRequest progressCiFileRequest = new ProgressCiFileRequest(this.channel, this.databaseGuid, seedingHandle);
            int      num     = -1;
            TimeSpan timeout = TimeSpan.FromSeconds((double)RegistryParameters.SeedCatalogProgressIntervalInSec);
            int      progress;

            for (;;)
            {
                progressCiFileRequest.Send();
                replayStopwatch.Restart();
                NetworkChannelMessage message             = this.channel.GetMessage();
                ProgressCiFileReply   progressCiFileReply = message as ProgressCiFileReply;
                if (progressCiFileReply == null)
                {
                    this.channel.ThrowUnexpectedMessage(message);
                }
                ExTraceGlobals.SeederServerTracer.TraceDebug <long>((long)this.GetHashCode(), "ProgressCiFile response took: {0}ms", replayStopwatch.ElapsedMilliseconds);
                progress = progressCiFileReply.Progress;
                ExTraceGlobals.SeederServerTracer.TraceDebug <int>((long)this.GetHashCode(), "Get seeding progress: {0}", progress);
                if (callback != null && callback.IsBackupCancelled())
                {
                    break;
                }
                if (progress < 0)
                {
                    goto Block_4;
                }
                if (progress > num)
                {
                    ExTraceGlobals.SeederServerTracer.TraceDebug <Guid, int, bool>((long)this.GetHashCode(), "Updating progress for catalog '{0}'. Percent = {1}%. Callback = {2}", this.databaseGuid, progress, callback != null);
                    if (callback != null)
                    {
                        callback.ReportProgress("IndexSystem", 102400L, (long)progress * 1024L, (long)progress * 1024L);
                    }
                    num = progress;
                }
                if (progress == 100)
                {
                    return;
                }
                Thread.Sleep(timeout);
            }
            ExTraceGlobals.SeederServerTracer.TraceDebug <int>((long)this.GetHashCode(), "The seeding was cancelled at {0}%", num);
            throw new SeederOperationAbortedException();
Block_4:
            Exception innerException = new CiSeederGenericException(this.sourceServerFqdn, this.targetServerFqdn, ReplayStrings.CiSeederExchangeSearchTransientException(string.Format("{0}", progress)));

            throw new PerformingFastOperationException(innerException);
        }
 // Token: 0x0600224A RID: 8778 RVA: 0x0009FE58 File Offset: 0x0009E058
 public override void CopyLog(long fromNumber, string destinationFileName, out DateTime writeTimeUtc)
 {
     writeTimeUtc = (DateTime)ExDateTime.UtcNow;
     ExTraceGlobals.LogCopyClientTracer.TraceDebug <string>((long)this.GetHashCode(), "CopyLog {0} starting", destinationFileName);
     base.AllocateBuffer();
     this.GetChannelLock();
     try
     {
         this.OpenChannelIfFirstRequest();
         CopyLogRequest msg = new CopyLogRequest(this.m_channel, this.DatabaseGuid, fromNumber);
         this.SendMessage(msg);
         ReplayStopwatch replayStopwatch = new ReplayStopwatch();
         replayStopwatch.Start();
         NetworkChannelMessage reply        = this.GetReply();
         CopyLogReply          copyLogReply = reply as CopyLogReply;
         if (copyLogReply == null)
         {
             this.m_channel.ThrowUnexpectedMessage(reply);
         }
         long elapsedMilliseconds = replayStopwatch.ElapsedMilliseconds;
         ExTraceGlobals.LogCopyClientTracer.TraceDebug <long>((long)this.GetHashCode(), "Log Copy Response took: {0}ms", elapsedMilliseconds);
         this.m_endOfLog.SetValue(copyLogReply.EndOfLogGeneration, new DateTime?(copyLogReply.EndOfLogUtc));
         writeTimeUtc = copyLogReply.LastWriteUtc;
         CheckSummer summer = null;
         if (this.m_channel.ChecksumDataTransfer)
         {
             summer = new CheckSummer();
         }
         copyLogReply.ReceiveFile(destinationFileName, null, summer);
         elapsedMilliseconds = replayStopwatch.ElapsedMilliseconds;
         ExTraceGlobals.LogCopyClientTracer.TraceDebug <long>((long)this.GetHashCode(), "Transmit/Decomp took: {0}ms", elapsedMilliseconds);
         base.RecordThruput(copyLogReply.FileSize);
         ExchangeNetworkPerfmonCounters perfCounters = this.m_channel.PerfCounters;
         if (perfCounters != null)
         {
             perfCounters.RecordLogCopyThruputReceived(copyLogReply.FileSize);
         }
         replayStopwatch.Stop();
         ExTraceGlobals.LogCopyClientTracer.TraceDebug((long)this.GetHashCode(), "{0}: LogCopy success: {1} for {2} after {3}ms", new object[]
         {
             ExDateTime.Now,
             replayStopwatch.ToString(),
             destinationFileName,
             replayStopwatch.ElapsedMilliseconds
         });
     }
     finally
     {
         this.ReleaseChannelLock();
     }
 }
        // Token: 0x06002248 RID: 8776 RVA: 0x0009FC80 File Offset: 0x0009DE80
        internal static void QueryLogRange(Guid dbGuid, NetworkChannel ch, out long minGen, out long maxGen, out DateTime maxGenUtc)
        {
            minGen    = 0L;
            maxGen    = 0L;
            maxGenUtc = DateTime.UtcNow;
            bool       flag             = false;
            int        timeoutToRestore = 0;
            TcpChannel tcpChannel       = null;

            try
            {
                tcpChannel = ch.TcpChannel;
                if (tcpChannel.ReadTimeoutInMs < RegistryParameters.QueryLogRangeTimeoutInMsec)
                {
                    timeoutToRestore           = tcpChannel.ReadTimeoutInMs;
                    tcpChannel.ReadTimeoutInMs = RegistryParameters.QueryLogRangeTimeoutInMsec;
                }
                QueryLogRangeRequest queryLogRangeRequest = new QueryLogRangeRequest(ch, dbGuid);
                queryLogRangeRequest.Send();
                NetworkChannelMessage message            = ch.GetMessage();
                QueryLogRangeReply    queryLogRangeReply = message as QueryLogRangeReply;
                if (queryLogRangeReply == null)
                {
                    ch.ThrowUnexpectedMessage(message);
                }
                minGen    = queryLogRangeReply.FirstAvailableGeneration;
                maxGen    = queryLogRangeReply.EndOfLogGeneration;
                maxGenUtc = queryLogRangeReply.EndOfLogUtc;
                ExTraceGlobals.LogCopyClientTracer.TraceDebug <long, long>((long)ch.GetHashCode(), "LogCopyClient:TryQueryLogRange: 0x{0:x} .. {1:x}", minGen, maxGen);
                flag = true;
            }
            finally
            {
                if (timeoutToRestore > 0)
                {
                    if (!flag)
                    {
                        NetworkChannel.RunNetworkFunction(delegate
                        {
                            tcpChannel.ReadTimeoutInMs = timeoutToRestore;
                        });
                    }
                    else
                    {
                        tcpChannel.ReadTimeoutInMs = timeoutToRestore;
                    }
                }
            }
        }
 private void HandleIncomingMessage()
 {
     try
     {
         if (!this.m_markedForTermination)
         {
             lock (this.m_networkReadLock)
             {
                 NetworkChannelMessage message     = this.Channel.GetMessage();
                 PingMessage           pingMessage = message as PingMessage;
                 if (pingMessage != null)
                 {
                     LogCopyServerContext.Tracer.TraceDebug((long)this.GetHashCode(), "HandleIncomingMessage: Ping received");
                     Interlocked.Exchange(ref this.m_pingPending, 1);
                     this.m_sendDataEnabled = true;
                 }
                 else
                 {
                     ContinuousLogCopyRequest2 continuousLogCopyRequest = message as ContinuousLogCopyRequest2;
                     if (continuousLogCopyRequest == null)
                     {
                         if (message is ContinuousLogCopyRequest)
                         {
                             continuousLogCopyRequest = LogCopyServerContext.UpgradeRequest(this.Channel, message as ContinuousLogCopyRequest);
                         }
                         else
                         {
                             LogCopyServerContext.Tracer.TraceError <NetworkChannelMessage>((long)this.GetHashCode(), "HandleIncomingMessage: UnexpectedMsg:{0}", message);
                             this.Channel.ThrowUnexpectedMessage(message);
                         }
                     }
                     LogCopyServerContext.Tracer.TraceDebug <long, long, ContinuousLogCopyRequest2.Flags>((long)this.GetHashCode(), "HandleIncomingMessage: First=0x{0:X} Max=0x{1:X} Flags=0x{2:X}", continuousLogCopyRequest.FirstGeneration, continuousLogCopyRequest.LastGeneration, continuousLogCopyRequest.FlagsUsed);
                     this.m_sendDataEnabled    = true;
                     this.m_nextLogCopyRequest = continuousLogCopyRequest;
                 }
                 this.StartNetworkRead();
                 this.SignalWorkPending();
             }
         }
     }
     catch (NetworkTransportException arg)
     {
         LogCopyServerContext.Tracer.TraceError <NetworkTransportException>((long)this.GetHashCode(), "HandleIncomingMessage: Channel exception: {0}", arg);
         this.MarkForTermination();
     }
 }
        // Token: 0x06002247 RID: 8775 RVA: 0x0009FB60 File Offset: 0x0009DD60
        public override long QueryLogRange()
        {
            long       num        = 0L;
            bool       flag       = false;
            int        num2       = 0;
            TcpChannel tcpChannel = null;

            this.GetChannelLock();
            try
            {
                this.OpenChannelIfFirstRequest();
                tcpChannel = this.m_channel.TcpChannel;
                if (tcpChannel.ReadTimeoutInMs < RegistryParameters.QueryLogRangeTimeoutInMsec)
                {
                    num2 = tcpChannel.ReadTimeoutInMs;
                    tcpChannel.ReadTimeoutInMs = RegistryParameters.QueryLogRangeTimeoutInMsec;
                }
                QueryLogRangeRequest msg = new QueryLogRangeRequest(this.m_channel, this.DatabaseGuid);
                this.SendMessage(msg);
                NetworkChannelMessage reply = this.GetReply();
                QueryLogRangeReply    queryLogRangeReply = reply as QueryLogRangeReply;
                if (queryLogRangeReply == null)
                {
                    this.m_channel.ThrowUnexpectedMessage(reply);
                }
                this.m_endOfLog.SetValue(queryLogRangeReply.EndOfLogGeneration, new DateTime?(queryLogRangeReply.EndOfLogUtc));
                num = queryLogRangeReply.FirstAvailableGeneration;
                ExTraceGlobals.LogCopyClientTracer.TraceDebug <long, long>((long)this.GetHashCode(), "LogCopyClient:QueryLogRange: 0x{0:x} .. {1:x}", num, this.m_endOfLog.Generation);
                flag = true;
            }
            finally
            {
                if (!flag)
                {
                    this.DiscardChannel();
                }
                else if (num2 > 0)
                {
                    tcpChannel.ReadTimeoutInMs = num2;
                }
                this.ReleaseChannelLock();
            }
            return(num);
        }
        // Token: 0x0600224B RID: 8779 RVA: 0x000A000C File Offset: 0x0009E20C
        internal static void CopyLog(Guid dbGuid, NetworkChannel ch, long logGen, string destinationFileName)
        {
            ExTraceGlobals.LogCopyClientTracer.TraceDebug <string>((long)ch.GetHashCode(), "static CopyLog {0} starting", destinationFileName);
            CopyLogRequest copyLogRequest = new CopyLogRequest(ch, dbGuid, logGen);

            copyLogRequest.Send();
            ReplayStopwatch replayStopwatch = new ReplayStopwatch();

            replayStopwatch.Start();
            NetworkChannelMessage message      = ch.GetMessage();
            CopyLogReply          copyLogReply = message as CopyLogReply;

            if (copyLogReply == null)
            {
                ch.ThrowUnexpectedMessage(message);
            }
            long elapsedMilliseconds = replayStopwatch.ElapsedMilliseconds;

            ExTraceGlobals.LogCopyClientTracer.TraceDebug <long>((long)ch.GetHashCode(), "Log Copy Response took: {0}ms", elapsedMilliseconds);
            CheckSummer summer = null;

            if (ch.ChecksumDataTransfer)
            {
                summer = new CheckSummer();
            }
            copyLogReply.ReceiveFile(destinationFileName, null, summer);
            elapsedMilliseconds = replayStopwatch.ElapsedMilliseconds;
            ExTraceGlobals.LogCopyClientTracer.TraceDebug <long>((long)ch.GetHashCode(), "Transmit/Decomp took: {0}ms", elapsedMilliseconds);
            ExchangeNetworkPerfmonCounters perfCounters = ch.PerfCounters;

            if (perfCounters != null)
            {
                perfCounters.RecordLogCopyThruputReceived(copyLogReply.FileSize);
            }
            replayStopwatch.Stop();
            ExTraceGlobals.LogCopyClientTracer.TraceDebug((long)ch.GetHashCode(), "{0}: LogCopy success: {1} for {2} after {3}ms", new object[]
            {
                ExDateTime.Now,
                replayStopwatch.ToString(),
                destinationFileName,
                replayStopwatch.ElapsedMilliseconds
            });
        }
Esempio n. 13
0
        // Token: 0x06000B90 RID: 2960 RVA: 0x0003339C File Offset: 0x0003159C
        public long ReadPageSize()
        {
            this.m_pageSize = 3L;
            ExTraceGlobals.IncrementalReseederTracer.TraceDebug((long)this.GetHashCode(), "fetching the page size");
            Exception ex = null;

            try
            {
                this.GetChannel();
                SeedPageReaderPageSizeRequest seedPageReaderPageSizeRequest = new SeedPageReaderPageSizeRequest(this.m_channel, this.m_databaseGuid, this.m_databaseName, this.m_databasePath);
                seedPageReaderPageSizeRequest.Send();
                NetworkChannelMessage       message = this.m_channel.GetMessage();
                SeedPageReaderPageSizeReply seedPageReaderPageSizeReply = message as SeedPageReaderPageSizeReply;
                if (seedPageReaderPageSizeReply == null)
                {
                    this.m_channel.ThrowUnexpectedMessage(message);
                }
                this.m_pageSize = seedPageReaderPageSizeReply.PageSize;
            }
            catch (NetworkRemoteException ex2)
            {
                ex = ex2;
            }
            catch (NetworkTransportException ex3)
            {
                ex = ex3;
            }
            if (ex != null)
            {
                ReplayEventLogConstants.Tuple_ReadPageSizeError.LogEvent(string.Empty, new object[]
                {
                    this.m_databaseName,
                    this.m_serverName,
                    ex
                });
                throw ex;
            }
            return(this.m_pageSize);
        }
Esempio n. 14
0
        // Token: 0x060019CA RID: 6602 RVA: 0x0006BDE4 File Offset: 0x00069FE4
        internal void SeedCatalog(string endpoint, IReplicaSeederCallback callback, string reason)
        {
            ExTraceGlobals.SeederServerTracer.TraceDebug <Guid, string>((long)this.GetHashCode(), "SeedCatalog {0} to {1}.", this.databaseGuid, endpoint);
            this.GetChannel();
            if (this.DoesSourceSupportExtensibleSeedingRequests())
            {
                SeedCiFileRequest2 seedCiFileRequest = new SeedCiFileRequest2(this.channel, this.databaseGuid, endpoint, reason);
                seedCiFileRequest.Send();
            }
            else
            {
                SeedCiFileRequest seedCiFileRequest2 = new SeedCiFileRequest(this.channel, this.databaseGuid, endpoint);
                seedCiFileRequest2.Send();
            }
            ReplayStopwatch replayStopwatch = new ReplayStopwatch();

            replayStopwatch.Start();
            NetworkChannelMessage message         = this.channel.GetMessage();
            SeedCiFileReply       seedCiFileReply = message as SeedCiFileReply;

            if (seedCiFileReply == null)
            {
                this.channel.ThrowUnexpectedMessage(message);
            }
            ExTraceGlobals.SeederServerTracer.TraceDebug <long>((long)this.GetHashCode(), "SeedCiFile response took: {0}ms", replayStopwatch.ElapsedMilliseconds);
            string handle = seedCiFileReply.Handle;

            ExTraceGlobals.SeederServerTracer.TraceDebug <string>((long)this.GetHashCode(), "Get seeding handle: {0}", handle);
            ExTraceGlobals.FaultInjectionTracer.TraceTest(2911251773U);
            this.UpdateProgress(handle, callback);
            replayStopwatch.Stop();
            ExTraceGlobals.SeederServerTracer.TraceDebug((long)this.GetHashCode(), "{0}: SeedCatalog succeeded: {1} for {2} after {3} ms", new object[]
            {
                ExDateTime.Now,
                endpoint,
                this.databaseGuid,
                replayStopwatch.ElapsedMilliseconds
            });
        }
Esempio n. 15
0
        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);
        }
Esempio n. 16
0
        internal static bool TestHealth(string targetServer, int targetPort, int timeOutInMs, out string errMsg)
        {
            errMsg = null;
            NetworkChannel networkChannel = null;
            Exception      ex             = null;

            ExTraceGlobals.TcpChannelTracer.TraceFunction <string>(0L, "TcpHealthCheck: testing {0}", targetServer);
            try
            {
                ushort num = (ushort)targetPort;
                if (num == 0)
                {
                    num = 64327;
                }
                ITcpConnector tcpConnector = Dependencies.TcpConnector;
                NetworkPath   netPath      = tcpConnector.BuildDnsNetworkPath(targetServer, (int)num);
                networkChannel = NetworkChannel.Connect(netPath, TcpChannel.GetDefaultTimeoutInMs(), false);
                TestHealthRequest testHealthRequest = new TestHealthRequest(networkChannel);
                testHealthRequest.Send();
                NetworkChannelMessage message = networkChannel.GetMessage();
                if (!(message is TestHealthReply))
                {
                    networkChannel.ThrowUnexpectedMessage(message);
                }
                ExTraceGlobals.TcpChannelTracer.TraceFunction <string>(0L, "TcpHealthCheck: {0} is healthy", targetServer);
                return(true);
            }
            catch (NetworkRemoteException ex2)
            {
                ex = ex2.InnerException;
            }
            catch (NetworkTransportException ex3)
            {
                ex = ex3;
            }
            catch (Win32Exception ex4)
            {
                ex = ex4;
            }
            catch (COMException ex5)
            {
                ex = ex5;
            }
            catch (ClusCommonFailException ex6)
            {
                ex = ex6;
            }
            catch (ClusCommonTransientException ex7)
            {
                ex = ex7;
            }
            finally
            {
                if (networkChannel != null)
                {
                    networkChannel.Close();
                }
            }
            if (ex != null)
            {
                ExTraceGlobals.TcpChannelTracer.TraceError <Exception>(0L, "TcpHealthCheck: failed: {0}", ex);
                errMsg = ex.Message;
            }
            return(false);
        }
 // Token: 0x06002245 RID: 8773 RVA: 0x0009FB39 File Offset: 0x0009DD39
 private void SendMessage(NetworkChannelMessage msg)
 {
     msg.Send();
 }
Esempio n. 18
0
        internal static NetworkChannelMessage ReadMessage(NetworkChannel channel, byte[] headerBuf)
        {
            int num = 0;

            NetworkChannelMessage.MessageType messageType = (NetworkChannelMessage.MessageType)Serialization.DeserializeUInt32(headerBuf, ref num);
            if (!NetworkChannelMessage.IsValidType(messageType))
            {
                throw new NetworkUnexpectedMessageException(channel.PartnerNodeName, string.Format("Unknown Type{0}", messageType));
            }
            int num2 = (int)Serialization.DeserializeUInt32(headerBuf, ref num);

            if (num2 < 16 || num2 > 1052672)
            {
                throw new NetworkUnexpectedMessageException(channel.PartnerNodeName, string.Format("Invalid msgLen: {0}", num2));
            }
            ExTraceGlobals.NetworkChannelTracer.TraceDebug <NetworkChannelMessage.MessageType, string, string>((long)channel.GetHashCode(), "ReadMessage: Received {0} from {1} on {2}", messageType, channel.RemoteEndPointString, channel.LocalEndPointString);
            byte[] array = new byte[num2];
            Array.Copy(headerBuf, 0, array, 0, 16);
            int len = num2 - 16;

            channel.Read(array, 16, len);
            NetworkChannelMessage.MessageType messageType2 = messageType;
            if (messageType2 <= NetworkChannelMessage.MessageType.CompressionRequest)
            {
                if (messageType2 <= NetworkChannelMessage.MessageType.SeedLogCopyRequest)
                {
                    if (messageType2 <= NetworkChannelMessage.MessageType.Ping)
                    {
                        if (messageType2 <= NetworkChannelMessage.MessageType.PassiveStatus)
                        {
                            if (messageType2 == NetworkChannelMessage.MessageType.TestNetwork0)
                            {
                                return(new TestNetwork0Request(channel, array));
                            }
                            if (messageType2 != NetworkChannelMessage.MessageType.PassiveStatus)
                            {
                                goto IL_51C;
                            }
                            return(new PassiveStatusMsg(channel, array));
                        }
                        else
                        {
                            if (messageType2 == NetworkChannelMessage.MessageType.CompressionConfig)
                            {
                                return(new NetworkChannelCompressionConfigMsg(channel, array));
                            }
                            if (messageType2 != NetworkChannelMessage.MessageType.BlockModeCompressedData)
                            {
                                if (messageType2 != NetworkChannelMessage.MessageType.Ping)
                                {
                                    goto IL_51C;
                                }
                                return(new PingMessage(channel, array));
                            }
                        }
                    }
                    else if (messageType2 <= NetworkChannelMessage.MessageType.EnterBlockMode)
                    {
                        if (messageType2 == NetworkChannelMessage.MessageType.GranularTermination)
                        {
                            return(new GranularTerminationMsg(channel, array));
                        }
                        if (messageType2 != NetworkChannelMessage.MessageType.GranularLogData)
                        {
                            if (messageType2 != NetworkChannelMessage.MessageType.EnterBlockMode)
                            {
                                goto IL_51C;
                            }
                            return(new EnterBlockModeMsg(channel, array));
                        }
                    }
                    else
                    {
                        if (messageType2 == NetworkChannelMessage.MessageType.GetE00GenerationRequest)
                        {
                            return(new GetE00GenerationRequest(channel, array));
                        }
                        if (messageType2 == NetworkChannelMessage.MessageType.CancelCiFileRequest)
                        {
                            return(new CancelCiFileRequest(channel, array));
                        }
                        if (messageType2 != NetworkChannelMessage.MessageType.SeedLogCopyRequest)
                        {
                            goto IL_51C;
                        }
                        return(new SeedLogCopyRequest(channel, array));
                    }
                    throw new NetworkUnexpectedMessageException(channel.PartnerNodeName, string.Format("ReadMessage() does not support message type: {0}.", messageType));
                }
                if (messageType2 <= NetworkChannelMessage.MessageType.CopyLogRequest)
                {
                    if (messageType2 <= NetworkChannelMessage.MessageType.SeedDatabaseFileRequest)
                    {
                        if (messageType2 == NetworkChannelMessage.MessageType.PassiveDatabaseFileRequest)
                        {
                            return(new PassiveSeedDatabaseFileRequest(channel, array));
                        }
                        if (messageType2 == NetworkChannelMessage.MessageType.SeedDatabaseFileRequest)
                        {
                            return(new SeedDatabaseFileRequest(channel, array));
                        }
                    }
                    else
                    {
                        switch (messageType2)
                        {
                        case NetworkChannelMessage.MessageType.ContinuousLogCopyRequest:
                            return(new ContinuousLogCopyRequest(channel, array));

                        case (NetworkChannelMessage.MessageType) 1363627076:
                            break;

                        case NetworkChannelMessage.MessageType.NotifyEndOfLogRequest:
                            return(new NotifyEndOfLogRequest(channel, array));

                        default:
                            if (messageType2 == NetworkChannelMessage.MessageType.TestLogExistenceRequest)
                            {
                                return(new TestLogExistenceRequest(channel, array));
                            }
                            if (messageType2 == NetworkChannelMessage.MessageType.CopyLogRequest)
                            {
                                return(new CopyLogRequest(channel, array));
                            }
                            break;
                        }
                    }
                }
                else if (messageType2 <= NetworkChannelMessage.MessageType.SeedPageReaderRollLogFileRequest)
                {
                    if (messageType2 == NetworkChannelMessage.MessageType.QueryLogRangeRequest)
                    {
                        return(new QueryLogRangeRequest(channel, array));
                    }
                    if (messageType2 == NetworkChannelMessage.MessageType.TestHealthRequest)
                    {
                        return(new TestHealthRequest(channel, array));
                    }
                    if (messageType2 == NetworkChannelMessage.MessageType.SeedPageReaderRollLogFileRequest)
                    {
                        return(new SeedPageReaderRollLogFileRequest(channel, array));
                    }
                }
                else
                {
                    if (messageType2 == NetworkChannelMessage.MessageType.SeedPageReaderMultiplePageRequest)
                    {
                        return(new SeedPageReaderMultiplePageRequest(channel, array));
                    }
                    if (messageType2 == NetworkChannelMessage.MessageType.ProgressCiFileRequest)
                    {
                        return(new ProgressCiFileRequest(channel, array));
                    }
                    if (messageType2 == NetworkChannelMessage.MessageType.CompressionRequest)
                    {
                        return(new NetworkChannelCompressionRequest(channel, array));
                    }
                }
            }
            else if (messageType2 <= NetworkChannelMessage.MessageType.SeedDatabaseFileReply)
            {
                if (messageType2 <= NetworkChannelMessage.MessageType.ContinuousLogCopyRequest2)
                {
                    if (messageType2 <= NetworkChannelMessage.MessageType.SeedCiFileRequest)
                    {
                        if (messageType2 == NetworkChannelMessage.MessageType.SeedPageReaderSinglePageRequest)
                        {
                            return(new SeedPageReaderSinglePageRequest(channel, array));
                        }
                        if (messageType2 == NetworkChannelMessage.MessageType.SeedCiFileRequest)
                        {
                            return(new SeedCiFileRequest(channel, array));
                        }
                    }
                    else
                    {
                        if (messageType2 == NetworkChannelMessage.MessageType.SeedCiFileRequest2)
                        {
                            return(new SeedCiFileRequest2(channel, array));
                        }
                        if (messageType2 == NetworkChannelMessage.MessageType.SeedPageReaderPageSizeRequest)
                        {
                            return(new SeedPageReaderPageSizeRequest(channel, array));
                        }
                        if (messageType2 == NetworkChannelMessage.MessageType.ContinuousLogCopyRequest2)
                        {
                            return(new ContinuousLogCopyRequest2(channel, array));
                        }
                    }
                }
                else if (messageType2 <= NetworkChannelMessage.MessageType.GetE00GenerationReply)
                {
                    if (messageType2 == NetworkChannelMessage.MessageType.LogCopyServerStatus)
                    {
                        return(new LogCopyServerStatusMsg(channel, array));
                    }
                    if (messageType2 == NetworkChannelMessage.MessageType.GranularLogComplete)
                    {
                        return(new GranularLogCompleteMsg(channel, array));
                    }
                    if (messageType2 == NetworkChannelMessage.MessageType.GetE00GenerationReply)
                    {
                        return(new GetE00GenerationReply(channel, array));
                    }
                }
                else
                {
                    if (messageType2 == NetworkChannelMessage.MessageType.NotifyEndOfLogAsyncReply)
                    {
                        return(new NotifyEndOfLogAsyncReply(channel, array));
                    }
                    if (messageType2 == NetworkChannelMessage.MessageType.CancelCiFileReply)
                    {
                        return(new CancelCiFileReply(channel, array));
                    }
                    if (messageType2 == NetworkChannelMessage.MessageType.SeedDatabaseFileReply)
                    {
                        return(new SeedDatabaseFileReply(channel, array));
                    }
                }
            }
            else if (messageType2 <= NetworkChannelMessage.MessageType.TestHealthReply)
            {
                if (messageType2 <= NetworkChannelMessage.MessageType.TestLogExistenceReply)
                {
                    if (messageType2 == NetworkChannelMessage.MessageType.NotifyEndOfLogReply)
                    {
                        return(new NotifyEndOfLogReply(channel, messageType, array));
                    }
                    if (messageType2 == NetworkChannelMessage.MessageType.TestLogExistenceReply)
                    {
                        return(new TestLogExistenceReply(channel, array));
                    }
                }
                else
                {
                    if (messageType2 == NetworkChannelMessage.MessageType.CopyLogReply)
                    {
                        return(new CopyLogReply(channel, array));
                    }
                    if (messageType2 == NetworkChannelMessage.MessageType.QueryLogRangeReply)
                    {
                        return(new QueryLogRangeReply(channel, array));
                    }
                    if (messageType2 == NetworkChannelMessage.MessageType.TestHealthReply)
                    {
                        return(new TestHealthReply(channel, array));
                    }
                }
            }
            else if (messageType2 <= NetworkChannelMessage.MessageType.CompressionReply)
            {
                if (messageType2 == NetworkChannelMessage.MessageType.SeedPageReaderRollLogFileReply)
                {
                    return(new SeedPageReaderRollLogFileReply(channel, array));
                }
                if (messageType2 == NetworkChannelMessage.MessageType.ProgressCiFileReply)
                {
                    return(new ProgressCiFileReply(channel, array));
                }
                if (messageType2 == NetworkChannelMessage.MessageType.CompressionReply)
                {
                    return(new NetworkChannelCompressionReply(channel, array));
                }
            }
            else
            {
                if (messageType2 == NetworkChannelMessage.MessageType.SeedPageReaderSinglePageReply)
                {
                    return(new SeedPageReaderSinglePageReply(channel, array));
                }
                if (messageType2 == NetworkChannelMessage.MessageType.SeedCiFileReply)
                {
                    return(new SeedCiFileReply(channel, array));
                }
                if (messageType2 == NetworkChannelMessage.MessageType.SeedPageReaderPageSizeReply)
                {
                    return(new SeedPageReaderPageSizeReply(channel, array));
                }
            }
IL_51C:
            throw new NetworkUnexpectedMessageException(channel.PartnerNodeName, string.Format("Unknown message type: 0x{0:X}", (int)messageType));
        }
        private bool EnterBlockMode()
        {
            TimeSpan  timeout = TimeSpan.FromSeconds(5.0);
            bool      flag;
            Exception ex = AmStoreHelper.IsDatabaseMounted(this.Database.DatabaseGuid, this.LocalNodeName, timeout, out flag);

            if (ex != null)
            {
                LogCopyServerContext.Tracer.TraceError <Exception>((long)this.GetHashCode(), "Store may not be running. Mount check failed: {0}", ex);
                return(false);
            }
            if (!flag)
            {
                LogCopyServerContext.Tracer.TraceDebug <string>((long)this.GetHashCode(), "Db {0} not mounted. BlockMode is not possible", this.Database.DatabaseName);
                return(false);
            }
            EnterBlockModeMsg enterBlockModeMsg = new EnterBlockModeMsg(this.Channel, EnterBlockModeMsg.Flags.PrepareToEnter, this.Database.DatabaseGuid, this.m_currentLogGeneration);
            bool flag2 = false;
            bool result;

            lock (this.m_networkReadLock)
            {
                if (this.m_markedForTermination)
                {
                    result = false;
                }
                else
                {
                    int readTimeoutInMs  = this.Channel.TcpChannel.ReadTimeoutInMs;
                    int writeTimeoutInMs = this.Channel.TcpChannel.WriteTimeoutInMs;
                    try
                    {
                        this.Channel.TcpChannel.ReadTimeoutInMs  = RegistryParameters.LogShipACLLTimeoutInMsec;
                        this.Channel.TcpChannel.WriteTimeoutInMs = RegistryParameters.LogShipACLLTimeoutInMsec;
                        LogCopyServerContext.Tracer.TraceDebug <string>((long)this.GetHashCode(), "EnterBlockMode requesting PrepareToEnter for {0}", this.PassiveCopyName);
                        enterBlockModeMsg.Send();
                        EnterBlockModeMsg enterBlockModeMsg2;
                        string            text;
                        for (;;)
                        {
                            NetworkChannelMessage message     = this.Channel.GetMessage();
                            PingMessage           pingMessage = message as PingMessage;
                            if (pingMessage != null)
                            {
                                LogCopyServerContext.Tracer.TraceDebug((long)this.GetHashCode(), "PingMessage ignored");
                            }
                            else
                            {
                                ContinuousLogCopyRequest2 continuousLogCopyRequest = message as ContinuousLogCopyRequest2;
                                if (continuousLogCopyRequest != null)
                                {
                                    this.m_nextLogCopyRequest = continuousLogCopyRequest;
                                    LogCopyServerContext.Tracer.TraceDebug <long, long, ContinuousLogCopyRequest2.Flags>((long)this.GetHashCode(), "ContinuousLogCopyRequest2: First=0x{0:X} Max=0x{1:X} Flags=0x{2:X}", continuousLogCopyRequest.FirstGeneration, continuousLogCopyRequest.LastGeneration, continuousLogCopyRequest.FlagsUsed);
                                }
                                else
                                {
                                    enterBlockModeMsg2 = (message as EnterBlockModeMsg);
                                    text = null;
                                    if (enterBlockModeMsg2 == null)
                                    {
                                        text = string.Format("Passive({0}) sent unexpected msg: {1}", this.PassiveCopyName, message.GetType());
                                    }
                                    else if (enterBlockModeMsg2.AckCounter != enterBlockModeMsg.AckCounter)
                                    {
                                        text = string.Format("Passive({0}) is out of sync. BlockModeEntry Aborted", this.PassiveCopyName);
                                    }
                                    if (text != null)
                                    {
                                        break;
                                    }
                                    if (enterBlockModeMsg2.FlagsUsed != EnterBlockModeMsg.Flags.PassiveIsReady)
                                    {
                                        goto Block_13;
                                    }
                                    if (!this.RequestBlockModeInStore())
                                    {
                                        goto Block_15;
                                    }
                                }
                            }
                        }
                        LogCopyServerContext.Tracer.TraceError((long)this.GetHashCode(), text);
                        throw new NetworkUnexpectedMessageException(this.m_clientNodeName, text);
Block_13:
                        if (enterBlockModeMsg2.FlagsUsed == EnterBlockModeMsg.Flags.PassiveReject)
                        {
                            LogCopyServerContext.Tracer.TraceError <string>((long)this.GetHashCode(), "BlockMode rejected by passive {0}", this.PassiveCopyName);
                            flag2 = true;
                            return(false);
                        }
                        text = string.Format("Passive({0}) passed unexpected flags 0x{1X}", this.PassiveCopyName, enterBlockModeMsg2.FlagsUsed);
                        throw new NetworkUnexpectedMessageException(this.m_clientNodeName, text);
Block_15:
                        flag2  = true;
                        result = false;
                    }
                    finally
                    {
                        if (flag2)
                        {
                            this.Channel.TcpChannel.ReadTimeoutInMs  = readTimeoutInMs;
                            this.Channel.TcpChannel.WriteTimeoutInMs = writeTimeoutInMs;
                            this.StartNetworkRead();
                        }
                    }
                }
            }
            return(result);
        }