Example #1
0
        // return true if there will be no more frames to copy (complete)
        public static async Task <bool> CopyNextFrameAsync(Stream inputStream, Stream outputStream, string traceType)
        {
            try
            {
                var intSegment = new ArraySegment <byte>(new byte[sizeof(int)]);

                var marker = await SerializationHelper.ReadIntAsync(intSegment, inputStream).ConfigureAwait(false);

                if (marker == BeginFrameMarker)
                {
                    // write the marker
                    await outputStream.WriteAsync(intSegment.Array, intSegment.Offset, intSegment.Count).ConfigureAwait(false);

                    // copy the bytes for this frame
                    await CopyListElementsFrameAsync(inputStream, outputStream, traceType).ConfigureAwait(false);

                    return(false);
                }
                else if (marker == EndFramesMarker)
                {
                    // write the end marker, and the copy is complete
                    await outputStream.WriteAsync(intSegment.Array, intSegment.Offset, intSegment.Count).ConfigureAwait(false);

                    return(true);
                }
                else
                {
                    var exc = new InvalidDataException(string.Format("CheckpointFileHelper.CopyNextFrameAsync => Marker : {0}", marker));
                    FabricEvents.Events.ReliableConcurrentQueue_ExceptionError(traceType, exc.ToString());
                    throw exc;
                }
            }
            catch (Exception ex)
            {
                FabricEvents.Events.ReliableConcurrentQueue_CopyNextFrameError("ReliableConcurrentQueueCheckpointFile.CopyNextFrameAsync@", ex.ToString());
                throw;
            }
        }
Example #2
0
        public static async Task <bool> WriteFrameAsync(ArraySegment <byte> frame, Stream stream, string traceType)
        {
            bool complete;

            var marker = BitConverter.ToInt32(frame.Array, frame.Offset);

            if (marker == BeginFrameMarker)
            {
                complete = false;
            }
            else if (marker == EndFramesMarker)
            {
                complete = true;
            }
            else
            {
                var exc = new InvalidDataException(string.Format("CheckpointFileHelper.WriteFrameAsync : marker = {0}", marker));
                FabricEvents.Events.ReliableConcurrentQueue_ExceptionError(traceType, exc.ToString());
                throw exc;
            }

            await stream.WriteAsync(frame.Array, frame.Offset, frame.Count).ConfigureAwait(false);

            return(complete);
        }
Example #3
0
        private static async Task CopyListElementsFrameAsync(Stream inputStream, Stream outputStream, string traceType)
        {
            var listElementsCountSegment = new ArraySegment <byte>(new byte[sizeof(int)]);
            var listElementsBytesSegment = new ArraySegment <byte>(new byte[sizeof(int)]);
            var crcSegment = new ArraySegment <byte>(new byte[sizeof(ulong)]);

            var listElementsCount = await SerializationHelper.ReadIntAsync(listElementsCountSegment, inputStream).ConfigureAwait(false);

            if (listElementsCount < 0)
            {
                var exc = new InvalidDataException(string.Format("CheckpointFileHelper.CopyListElementsFrameAsync : Unexpected listElementsCount: {0}", listElementsCount));
                FabricEvents.Events.ReliableConcurrentQueue_ExceptionError(traceType, exc.ToString());
                throw exc;
            }

            var listElementsBytes = await SerializationHelper.ReadIntAsync(listElementsBytesSegment, inputStream).ConfigureAwait(false);

            if (listElementsBytes < 0)
            {
                var exc = new InvalidDataException(string.Format("CheckpointFileHelper.CopyListElementsFrameAsync : Unexpected listElementsBytes: {0}", listElementsBytes));
                FabricEvents.Events.ReliableConcurrentQueue_ExceptionError(traceType, exc.ToString());
                throw exc;
            }

            var listElementsSegment = new ArraySegment <byte>(new byte[listElementsBytes]);
            await SerializationHelper.ReadBytesAsync(listElementsSegment, listElementsBytes, inputStream).ConfigureAwait(false);

            await SerializationHelper.ReadBytesAsync(crcSegment, sizeof(ulong), inputStream).ConfigureAwait(false);

            var readCRC = BitConverter.ToUInt64(crcSegment.Array, crcSegment.Offset);

            var calcCrc = CRC64.ToCRC64(new[] { listElementsCountSegment, listElementsBytesSegment, listElementsSegment });

            if (calcCrc != readCRC)
            {
                var exc = new InvalidDataException(string.Format("CheckpointFileHelper.CopyListElementsFrameAsync => CRC mismatch.  Read: {0} Calculated: {1}", readCRC, calcCrc));
                FabricEvents.Events.ReliableConcurrentQueue_ExceptionError(traceType, exc.ToString());
                throw exc;
            }

            await outputStream.WriteAsync(listElementsCountSegment.Array, listElementsCountSegment.Offset, listElementsCountSegment.Count).ConfigureAwait(false);

            await outputStream.WriteAsync(listElementsBytesSegment.Array, listElementsBytesSegment.Offset, listElementsBytesSegment.Count).ConfigureAwait(false);

            await outputStream.WriteAsync(listElementsSegment.Array, listElementsSegment.Offset, listElementsSegment.Count).ConfigureAwait(false);

            await outputStream.WriteAsync(crcSegment.Array, crcSegment.Offset, crcSegment.Count).ConfigureAwait(false);
        }