コード例 #1
0
 public static CopyModeResult CreateCopyNoneResult(SharedProgressVectorEntry sharedProgressVectorEntry)
 {
     return(new CopyModeResult
     {
         SharedProgressVectorEntry = sharedProgressVectorEntry,
         SourceStartingLsn = LogicalSequenceNumber.InvalidLsn,
         TargetStartingLsn = LogicalSequenceNumber.InvalidLsn,
         CopyMode = CopyMode.None
     });
 }
コード例 #2
0
 public static CopyModeResult CreatePartialCopyResult(
     SharedProgressVectorEntry sharedProgressVectorEntry,
     LogicalSequenceNumber sourceStartingLsn,
     LogicalSequenceNumber targetStartingLsn)
 {
     return(new CopyModeResult
     {
         SourceStartingLsn = sourceStartingLsn,
         TargetStartingLsn = targetStartingLsn,
         CopyMode = CopyMode.Partial,
         SharedProgressVectorEntry = sharedProgressVectorEntry
     });
 }
コード例 #3
0
        public static CopyModeResult CreateFullCopyResult(
            SharedProgressVectorEntry sharedProgressVectorEntry,
            FullCopyReason reason)
        {
            Utility.Assert(reason != FullCopyReason.Invalid, "reason!= FullCopyReason.Invalid");

            return(new CopyModeResult
            {
                SharedProgressVectorEntry = sharedProgressVectorEntry,
                SourceStartingLsn = LogicalSequenceNumber.InvalidLsn,
                TargetStartingLsn = LogicalSequenceNumber.InvalidLsn,
                CopyMode = CopyMode.Full,
                FullCopyReason = reason
            });
        }
コード例 #4
0
        public static CopyModeResult CreateFalseProgressResult(
            long lastRecoveredAtomicRedoOperationLsnAtTarget,
            SharedProgressVectorEntry sharedProgressVectorEntry,
            LogicalSequenceNumber sourceStartingLsn,
            LogicalSequenceNumber targetStartingLsn)
        {
            if (lastRecoveredAtomicRedoOperationLsnAtTarget > sourceStartingLsn.LSN)
            {
                // Atomic Redo operations cannot be undone in false progress.
                // So resort to full copy
                return(CreateFullCopyResult(sharedProgressVectorEntry, FullCopyReason.AtomicRedoOperationFalseProgressed));
            }

            return(new CopyModeResult
            {
                SourceStartingLsn = sourceStartingLsn,
                TargetStartingLsn = targetStartingLsn,
                CopyMode = CopyMode.FalseProgress | CopyMode.Partial,
                SharedProgressVectorEntry = sharedProgressVectorEntry
            });
        }
コード例 #5
0
        internal static CopyModeResult FindCopyMode(
            CopyContextParameters sourceParamaters,
            CopyContextParameters targetParameters,
            long lastRecoveredAtomicRedoOperationLsnAtTarget)
        {
            var result = FindCopyModePrivate(sourceParamaters, targetParameters, lastRecoveredAtomicRedoOperationLsnAtTarget);

            if (result.CopyMode.HasFlag(CopyMode.FalseProgress))
            {
                string failureMsg = string.Format(
                    "(sourceStartingLsn is expected to be lesser or equal to targetStartingLsn). Source starting lsn : {0}, target starting lsn :{1} ",
                    result.SourceStartingLsn.LSN,
                    result.TargetStartingLsn.LSN);

                if (!ValidateIfDebugEnabled(
                        result.SourceStartingLsn <= result.TargetStartingLsn,
                        failureMsg))
                {
                    SharedProgressVectorEntry failedValidationResult = new SharedProgressVectorEntry
                    {
                        SourceIndex = result.SharedProgressVectorEntry.SourceIndex,
                        TargetIndex = result.SharedProgressVectorEntry.TargetIndex,
                        SourceProgressVectorEntry = result.SharedProgressVectorEntry.SourceProgressVectorEntry,
                        TargetProgressVectorEntry = result.SharedProgressVectorEntry.TargetProgressVectorEntry,
                        FullCopyReason            = FullCopyReason.ValidationFailed,
                        FailedValidationMessage   = failureMsg
                    };

                    return(CopyModeResult.CreateFullCopyResult(
                               failedValidationResult,
                               FullCopyReason.ValidationFailed));
                }
            }

            return(result);
        }
コード例 #6
0
        internal static SharedProgressVectorEntry FindSharedVector(
            ProgressVector sourceProgressVector,
            ProgressVector targetProgressVector)
        {
            // Initialize indices
            var sourceIndex = sourceProgressVector.vectors.Count - 1;
            var targetIndex = targetProgressVector.vectors.Count - 1;

            Utility.Assert(
                targetProgressVector.vectors[targetIndex].Epoch.DataLossNumber <= sourceProgressVector.vectors[sourceIndex].Epoch.DataLossNumber,
                "targetDataLossNumber ({0}) <= sourceDataLossNumber ({1})",
                targetProgressVector.vectors[targetIndex].Epoch.DataLossNumber, sourceProgressVector.vectors[sourceIndex].Epoch.DataLossNumber);

            SharedProgressVectorEntry progrssVectorTrimmedResult = new SharedProgressVectorEntry()
            {
                FullCopyReason = FullCopyReason.ProgressVectorTrimmed
            };

            do
            {
                bool decrementIndexSuccess = DecrementIndexUntilLeq(
                    ref targetIndex,
                    targetProgressVector,
                    sourceProgressVector.vectors[sourceIndex]);

                if (!decrementIndexSuccess)
                {
                    return(progrssVectorTrimmedResult);
                }

                decrementIndexSuccess = DecrementIndexUntilLeq(
                    ref sourceIndex,
                    sourceProgressVector,
                    targetProgressVector.vectors[targetIndex]);

                if (!decrementIndexSuccess)
                {
                    return(progrssVectorTrimmedResult);
                }
            } while (sourceProgressVector.vectors[sourceIndex] != targetProgressVector.vectors[targetIndex]);

            var sourceProgressVectorEntry = sourceProgressVector.vectors[sourceIndex];
            var targetProgressVectorEntry = targetProgressVector.vectors[targetIndex];

            // WITHOUT MINI RECONFIG ENABLED, it is not possible for the target to make VALID progress TWICE from the shared epoch
            // Note that this check is only valid in the absence of dataloss and restore.

            // E.g

            /*
             * Target Replica Copy Context: 131383889527030885
             *      TargetLogHeadEpoch: 0,0 TargetLogHeadLsn: 0 TargetLogTailEpoch: 131383889406148342,64424509440 TargetLogTailLSN: 73
             *      SourceLogHeadEpoch: 0,0 SourceLogHeadLsn: 0 SourceLogTailEpoch: 131383889406148342,68719476736 SourceLogTailLSN: 68
             *      Target ProgressVector: [(131383889406148342,64424509440),73,131383889527030885,2017-05-04T16:32:22]
             *                              [(131383889406148342,55834574848),68,131383889527030885,2017-05-04T16:31:54]
             *                              [(131383889406148342,51539607552),62,131383889416461059,2017-05-04T16:31:37]
             *                              [(131383889406148342,47244640256),56,131383889527030885,2017-05-04T16:31:20]
             *                              [(0,0),0,0,2017-05-04T16:29:07]
             *      Source ProgressVector: [(131383889406148342,68719476736),68,131383890970495929,2017-05-04T16:32:33]
             *                              [(131383889406148342,60129542144),68,131383890970495929,2017-05-04T16:32:09]
             *                              [(131383889406148342,51539607552),62,131383889416461059,2017-05-04T16:31:37]
             *                              [(131383889406148342,47244640256),56,131383889527030885,2017-05-04T16:31:20]
             *                              [(0,0),0,0,2017-05-04T16:31:33]
             *      LastRecoveredAtomicRedoOperationLsn: 0.
             *
             *
             *  Target Replica Copy Context: 131399770096882719
             *      TargetLogHeadEpoch: 0,0 TargetLogHeadLsn: 0 TargetLogTailEpoch: 131399758616683034,390842023936 TargetLogTailLSN: 374
             *      SourceLogHeadEpoch: 0,0 SourceLogHeadLsn: 0 SourceLogTailEpoch: 131399758616683034,395136991232 SourceLogTailLSN: 369
             *      Target ProgressVector:
             *                  [(131399758616683034,390842023936),374,131399770096882719,2017-05-23T01:42:03]
             *                  [(131399758616683034,382252089344),374,131399770096882719,2017-05-23T01:41:29]
             *                  [(131399758616683034,377957122048),369,131399770096882719,2017-05-23T01:41:00]
             *                  [(131399758616683034,373662154752),338,131399758632647497,2017-05-23T01:40:31]
             *      Source ProgressVector:
             *                  [(131399758616683034,395136991232),369,131399758701866693,2017-05-23T01:42:19]
             *                  [(131399758616683034,386547056640),369,131399758701866693,2017-05-23T01:41:44]
             *                  [(131399758616683034,373662154752),338,131399758632647497,2017-05-23T01:40:31]
             *      LastRecoveredAtomicRedoOperationLsn: 0
             */

            string failureMsg;

            if (targetProgressVector.LastProgressVectorEntry.Epoch.DataLossNumber
                == sourceProgressVector.LastProgressVectorEntry.Epoch.DataLossNumber &&
                targetIndex < targetProgressVector.vectors.Count - 1 &&
                targetProgressVector.LastProgressVectorEntry.Epoch.DataLossNumber == targetProgressVector.vectors[targetIndex].Epoch.DataLossNumber)
            {
                // Target replica could only have repeatedly attempted to become a
                // primary without ever making progress at the shared dataloss number
                // We can do "double progress check" only if there has NOT been any other data loss happening on the target after shared point. Having a differnt dataloss numbers in shared vector and target's tail
                // means that target has been a valid primary and progressed in LSN until hitting a dataloss and then a very old secondary can become primary and invalidate all the progress made by the target.
                var failureLsn            = targetProgressVector.vectors[targetIndex + 1].Lsn;
                var failureLsnIncremented = 0;

                for (var n = targetIndex + 2; n <= targetProgressVector.vectors.Count - 1; n++)
                {
                    var vector = targetProgressVector.vectors[n];
                    if (vector.Epoch.DataLossNumber != targetProgressVectorEntry.Epoch.DataLossNumber)
                    {
                        break;
                    }

                    if (vector.Lsn != failureLsn)
                    {
                        // Update failureLsn to ensure we don't assert if there are multiple entries for same LSN like in 2nd example above
                        failureLsn = vector.Lsn;
                        failureLsnIncremented++;
                    }
                }

                failureMsg = string.Format(
                    "FailureLsn incremented must be <= 1. It is {0}",
                    failureLsnIncremented);

                if (!ValidateIfDebugEnabled(
                        failureLsnIncremented <= 1,
                        failureMsg))
                {
                    return(new SharedProgressVectorEntry
                    {
                        SourceIndex = sourceIndex,
                        TargetIndex = targetIndex,
                        SourceProgressVectorEntry = sourceProgressVectorEntry,
                        TargetProgressVectorEntry = targetProgressVectorEntry,
                        FullCopyReason = FullCopyReason.ValidationFailed,
                        FailedValidationMessage = failureMsg
                    });
                }
            }

            // Sanity check that source and target progress vectors are always in
            // agreement upto above determined ProgressVectorEntry shared by both of them
            var i           = sourceIndex;
            var sourceEntry = sourceProgressVectorEntry;
            var j           = targetIndex;
            var targetEntry = targetProgressVectorEntry;

            failureMsg = "sourceEntry == targetEntry";

            do
            {
                sourceEntry = DecrementIndexUntilLsnIsEqual(ref i, sourceProgressVector, sourceEntry.Lsn.LSN);
                if (i == 0)
                {
                    break;
                }

                targetEntry = DecrementIndexUntilLsnIsEqual(ref j, targetProgressVector, targetEntry.Lsn.LSN);
                if (j == 0)
                {
                    break;
                }

                if (!ValidateIfDebugEnabled(
                        sourceEntry == targetEntry,
                        failureMsg))
                {
                    return(new SharedProgressVectorEntry
                    {
                        SourceIndex = sourceIndex,
                        TargetIndex = targetIndex,
                        SourceProgressVectorEntry = sourceProgressVectorEntry,
                        TargetProgressVectorEntry = targetProgressVectorEntry,
                        FullCopyReason = FullCopyReason.ValidationFailed,
                        FailedValidationMessage = failureMsg
                    });
                }
            } while (true);

            Utility.Assert(sourceProgressVectorEntry != null && targetProgressVectorEntry != null, "Source and target expected to be non null");

            return(new SharedProgressVectorEntry
            {
                SourceIndex = sourceIndex,
                TargetIndex = targetIndex,
                SourceProgressVectorEntry = sourceProgressVectorEntry,
                TargetProgressVectorEntry = targetProgressVectorEntry
            });
        }