public static Exception AssertAndFailFastService(string description)
{
Fx.Assert(description);
string failFastMessage = CommonResources.GetString(CommonResources.FailFastMessage, description);
// The catch is here to force the finally to run, as finallys don't run until the stack walk gets to a catch.
// The catch makes sure that the finally will run before the stack-walk leaves the frame, but the code inside is impossible to reach.
try
{
try
{
////MessagingClientEtwProvider.Provider.EventWriteFailFastOccurred(description);
Fx.Exception.TraceFailFast(failFastMessage);
// Mark that a FailFast is in progress, so that we can take ourselves out of the NLB if for
// any reason we can't kill ourselves quickly. Wait 15 seconds so this state gets picked up for sure.
Fx.FailFastInProgress = true;
#if !WINDOWS_UWP
Thread.Sleep(TimeSpan.FromSeconds(15));
#endif
}
finally
{
// ########################## NOTE ###########################
// Environment.FailFast does not collect crash dumps when used in Azure services.
// Environment.FailFast(failFastMessage);
#if !WINDOWS_UWP
// ################## WORKAROUND #############################
// Workaround for the issue above. Throwing an unhandled exception on a separate thread to trigger process crash and crash dump collection
// Throwing FatalException since our service does not morph/eat up fatal exceptions
// We should find the tracking bug in Azure for this issue, and remove the workaround when fixed by Azure
Thread failFastWorkaroundThread = new Thread(delegate()
{
throw new FatalException(failFastMessage);
});
failFastWorkaroundThread.Start();
failFastWorkaroundThread.Join();
#endif
}
}
catch
{
throw;
}
return(null); // we'll never get here since we've just fail-fasted
}
////public static DiagnosticTrace Trace
////{
//// get
//// {
//// if (diagnosticTrace == null)
//// {
//// diagnosticTrace = InitializeTracing();
//// }
//// return diagnosticTrace;
//// }
////}
public static byte[] AllocateByteArray(int size)
{
#if !NETSTANDARD
try
{
#endif
// Safe to catch OOM from this as long as the ONLY thing it does is a simple allocation of a primitive type (no method calls).
return(new byte[size]);
#if !NETSTANDARD
}
catch (OutOfMemoryException exception)
{
// Convert OOM into an exception that can be safely handled by higher layers.
throw Fx.Exception.AsError(new InsufficientMemoryException(CommonResources.GetString(CommonResources.BufferAllocationFailed, size), exception));
}
#endif
}
public void ExtractFrameBuffers(ByteBuffer buffer, SerializedWorker <ByteBuffer> bufferHandler)
{
if (this.currentFrameBuffer != null)
{
int sizeToWrite = Math.Min(this.currentFrameBuffer.Size, buffer.Length);
AmqpBitConverter.WriteBytes(this.currentFrameBuffer, buffer.Buffer, buffer.Offset, sizeToWrite);
buffer.Complete(sizeToWrite);
if (this.currentFrameBuffer.Size == 0)
{
ByteBuffer frameBuffer = this.currentFrameBuffer;
this.currentFrameBuffer = null;
bufferHandler.DoWork(frameBuffer);
}
}
while (buffer.Length >= AmqpCodec.MinimumFrameDecodeSize)
{
int frameSize = AmqpCodec.GetFrameSize(buffer);
if (frameSize < AmqpCodec.MinimumFrameDecodeSize || frameSize > this.maxFrameSize)
{
throw new AmqpException(AmqpErrorCode.FramingError, CommonResources.GetString(CommonResources.InvalidFrameSize, frameSize, this.maxFrameSize));
}
int sizeToWrite = Math.Min(frameSize, buffer.Length);
this.currentFrameBuffer = new ByteBuffer(frameSize, false);
AmqpBitConverter.WriteBytes(this.currentFrameBuffer, buffer.Buffer, buffer.Offset, sizeToWrite);
buffer.Complete(sizeToWrite);
if (frameSize == sizeToWrite)
{
ByteBuffer frameBuffer = this.currentFrameBuffer;
this.currentFrameBuffer = null;
bufferHandler.DoWork(frameBuffer);
}
else
{
break;
}
}
}
public AssertionFailedException(string description)
: base(CommonResources.GetString(CommonResources.ShipAssertExceptionMessage, description))
{
}
protected static void ThrowInvalidAsyncResult(IAsyncResult result)
{
throw new InvalidOperationException(CommonResources.GetString(CommonResources.InvalidAsyncResultImplementation, result.GetType()));
}
bool HandleReadComplete(TransportAsyncCallbackArgs args)
{
bool completed = true;
Exception exception = null;
if (args.Exception != null)
{
exception = args.Exception;
}
else if (args.BytesTransfered == 0)
{
exception = new ObjectDisposedException(this.transport.ToString());
}
else if (args.BytesTransfered == args.Count)
{
args.ByteBuffer?.Append(args.BytesTransfered);
}
else
{
completed = false;
if (args.ByteBuffer == null)
{
args.SetBuffer(args.Buffer, args.Offset + args.BytesTransfered, args.Count - args.BytesTransfered);
}
else
{
args.ByteBuffer.Append(args.BytesTransfered);
args.SetReadBuffer(args.ByteBuffer);
}
}
if (completed)
{
if (exception != null || object.ReferenceEquals(args.CompletedCallback, onFrameComplete))
{
ByteBuffer buffer = args.ByteBuffer;
try
{
if (exception == null)
{
this.parent.OnReceiveBuffer(buffer);
}
else
{
this.parent.OnIoFault(exception);
}
}
finally
{
buffer?.Dispose();
}
}
else
{
// read size completed ok
uint size = AmqpBitConverter.ReadUInt(this.sizeBuffer, 0, this.sizeBuffer.Length);
if (size > this.maxFrameSize)
{
completed = true;
exception = new AmqpException(AmqpErrorCode.FramingError, CommonResources.GetString(CommonResources.InvalidFrameSize, size, this.maxFrameSize));
this.parent.OnIoFault(exception);
}
else
{
ByteBuffer buffer = this.parent.CreateBuffer((int)size);
args.SetReadBuffer(buffer);
args.CompletedCallback = onFrameComplete;
completed = false;
}
}
}
return(completed);
}
public ArgumentException ArgumentNullOrWhiteSpace(string paramName)
{
return(this.Argument(paramName, CommonResources.GetString(CommonResources.ArgumentNullOrWhiteSpace, paramName)));
}
