protected override void Dispose(bool disposing)
{
if (disposing)
{
db.Dispose();
}
base.Dispose(disposing);
}
protected virtual void Dispose(bool disposing)
{
if (!this.disposed)
{
if (disposing)
{
_context.Dispose();
}
}
this.disposed = true;
}
void TryProcessIncomingMessage()
{
using (var transactionScope = BeginTransaction())
{
var transportMessage = receiveMessages.ReceiveMessage();
if (transportMessage == null)
{
Thread.Sleep(20);
return;
}
var id = transportMessage.Id;
var label = transportMessage.Label;
MessageContext context = null;
if (errorTracker.MessageHasFailedMaximumNumberOfTimes(id))
{
log.Error("Handling message {0} has failed the maximum number of times", id);
MessageFailedMaxNumberOfTimes(transportMessage, errorTracker.GetErrorText(id));
errorTracker.StopTracking(id);
try
{
PoisonMessage(transportMessage);
}
catch (Exception exceptionWhileRaisingEvent)
{
log.Error("An exception occurred while raising the PoisonMessage event: {0}",
exceptionWhileRaisingEvent);
}
}
else
{
try
{
BeforeTransportMessage(transportMessage);
var message = serializeMessages.Deserialize(transportMessage);
// successfully deserialized the transport message, let's enter a message context
context = MessageContext.Enter(message.Headers);
foreach (var logicalMessage in message.Messages)
{
context.SetLogicalMessage(logicalMessage);
try
{
BeforeMessage(logicalMessage);
var typeToDispatch = logicalMessage.GetType();
log.Debug("Dispatching message {0}: {1}", id, typeToDispatch);
GetDispatchMethod(typeToDispatch).Invoke(this, new[] { logicalMessage });
AfterMessage(null, logicalMessage);
}
catch (Exception exception)
{
try
{
AfterMessage(exception, logicalMessage);
}
catch (Exception exceptionWhileRaisingEvent)
{
log.Error("An exception occurred while raising the AfterMessage event, and an exception occurred some time before that as well. The first exception was this: {0}. And then, when raising the AfterMessage event (including the details of the first error), this exception occurred: {1}",
exception, exceptionWhileRaisingEvent);
}
throw;
}
finally
{
context.ClearLogicalMessage();
}
}
AfterTransportMessage(null, transportMessage);
}
catch (Exception exception)
{
log.Debug("Handling message {0} ({1}) has failed", label, id);
try
{
AfterTransportMessage(exception, transportMessage);
}
catch (Exception exceptionWhileRaisingEvent)
{
log.Error("An exception occurred while raising the AfterTransportMessage event, and an exception occurred some time before that as well. The first exception was this: {0}. And then, when raising the AfterTransportMessage event (including the details of the first error), this exception occurred: {1}",
exception, exceptionWhileRaisingEvent);
}
errorTracker.TrackDeliveryFail(id, exception);
if (context != null)
{
context.Dispose(); //< dispose it if we entered
}
throw;
}
}
transactionScope.Complete();
if (context != null)
{
context.Dispose(); //< dispose it if we entered
}
errorTracker.StopTracking(id);
}
}
void DoTry()
{
var transportMessage = receiveMessages.ReceiveMessage(TransactionContext.Current);
if (transportMessage == null)
{
// to back off and relax when there's no messages to process, we do this
nullMessageReceivedBackoffHelper.Wait();
return;
}
nullMessageReceivedBackoffHelper.Reset();
var id = transportMessage.Id;
var label = transportMessage.Label;
MessageContext context = null;
if (id == null)
{
HandlePoisonMessage(id, transportMessage);
return;
}
if (errorTracker.MessageHasFailedMaximumNumberOfTimes(id))
{
HandlePoisonMessage(id, transportMessage);
errorTracker.StopTracking(id);
return;
}
Exception transportMessageExceptionOrNull = null;
try
{
BeforeTransportMessage(transportMessage);
// Populate rebus-msg-id, if not set, from transport-level-id
if (!transportMessage.Headers.ContainsKey(Headers.MessageId))
{
transportMessage.Headers[Headers.MessageId] = transportMessage.Id;
}
using (var scope = BeginTransaction())
{
var message = serializeMessages.Deserialize(transportMessage);
// successfully deserialized the transport message, let's enter a message context
context = MessageContext.Establish(message.Headers);
MessageContextEstablished(context);
var unitsOfWork = unitOfWorkManagers.Select(u => u.Create())
.Where(u => !ReferenceEquals(null, u))
.ToArray(); //< remember to invoke the chain here :)
try
{
foreach (var logicalMessage in message.Messages.Select(MutateIncoming))
{
context.SetLogicalMessage(logicalMessage);
Exception logicalMessageExceptionOrNull = null;
try
{
BeforeMessage(logicalMessage);
var typeToDispatch = logicalMessage.GetType();
messageLogger.LogReceive(id, logicalMessage);
try
{
var dispatchMethod = GetDispatchMethod(typeToDispatch);
var parameters = new[] { logicalMessage };
dispatchMethod.Invoke(this, parameters);
}
catch (TargetInvocationException tie)
{
var exception = tie.InnerException;
exception.PreserveStackTrace();
throw exception;
}
}
catch (Exception exception)
{
logicalMessageExceptionOrNull = exception;
throw;
}
finally
{
try
{
AfterMessage(logicalMessageExceptionOrNull, logicalMessage);
}
catch (Exception exceptionWhileRaisingEvent)
{
if (logicalMessageExceptionOrNull != null)
{
log.Error(
"An exception occurred while raising the AfterMessage event, and an exception occurred some" +
" time before that as well. The first exception was this: {0}. And then, when raising the" +
" AfterMessage event (including the details of the first error), this exception occurred: {1}",
logicalMessageExceptionOrNull, exceptionWhileRaisingEvent);
}
else
{
log.Error("An exception occurred while raising the AfterMessage event: {0}",
exceptionWhileRaisingEvent);
}
}
context.ClearLogicalMessage();
}
}
foreach (var unitOfWork in unitsOfWork)
{
try
{
unitOfWork.Commit();
}
catch (Exception exception)
{
throw new UnitOfWorkCommitException(exception, unitOfWork);
}
}
}
catch
{
foreach (var unitOfWork in unitsOfWork)
{
try
{
unitOfWork.Abort();
}
catch (Exception abortException)
{
log.Warn("An error occurred while aborting the unit of work {0}: {1}",
unitOfWork, abortException);
}
}
throw;
}
finally
{
foreach (var unitOfWork in unitsOfWork)
{
unitOfWork.Dispose();
}
}
if (scope != null)
{
scope.Complete();
}
}
}
catch (Exception exception)
{
transportMessageExceptionOrNull = exception;
log.Debug("Handling message {0} with ID {1} has failed", label, id);
errorTracker.TrackDeliveryFail(id, exception);
throw new MessageHandleException(id, exception);
}
finally
{
try
{
AfterTransportMessage(transportMessageExceptionOrNull, transportMessage);
}
catch (Exception exceptionWhileRaisingEvent)
{
if (transportMessageExceptionOrNull != null)
{
log.Error(
"An exception occurred while raising the AfterTransportMessage event, and an exception occurred some" +
" time before that as well. The first exception was this: {0}. And then, when raising the" +
" AfterTransportMessage event (including the details of the first error), this exception occurred: {1}",
transportMessageExceptionOrNull, exceptionWhileRaisingEvent);
}
else
{
log.Error("An exception occurred while raising the AfterTransportMessage event: {0}", exceptionWhileRaisingEvent);
}
}
if (context != null)
{
context.Dispose(); //< dispose it if we entered
}
}
errorTracker.StopTracking(id);
}
public static void Main(string[] args)
{
bool debug = false;
bool verbose = false;
for (int i = 1; i < args.Length; i++)
{
string arg = args[i];
if (arg == "--debug")
{
debug = true;
}
else if (arg == "--verbose")
{
verbose = true;
}
else if (arg == "--console")
{
AllocConsole();
}
}
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;
SelfPath = Assembly.GetExecutingAssembly().Location;
RootDirectory = Path.GetDirectoryName(Environment.CurrentDirectory);
ConfigDirectory = Environment.GetEnvironmentVariable("OLYMPUS_CONFIG");
if (string.IsNullOrEmpty(ConfigDirectory) || !Directory.Exists(ConfigDirectory))
{
ConfigDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Olympus");
}
Console.Error.WriteLine(RootDirectory);
if (Type.GetType("Mono.Runtime") != null)
{
// Mono hates HTTPS.
ServicePointManager.ServerCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => {
return(true);
};
}
// Enable TLS 1.2 to fix connecting to GitHub.
ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls12;
if (args.Length >= 1 && args[0] == "--uninstall" && PlatformHelper.Is(Platform.Windows))
{
new CmdWin32AppUninstall().Run(args.Length >= 2 && args[1] == "--quiet");
return;
}
Process parentProc = null;
int parentProcID = 0;
TcpListener listener = new TcpListener(IPAddress.Loopback, 0);
List <Thread> threads = new List <Thread>();
listener.Start();
Console.WriteLine($"{((IPEndPoint) listener.LocalEndpoint).Port}");
try {
parentProc = Process.GetProcessById(parentProcID = int.Parse(args.Last()));
} catch {
Console.Error.WriteLine("[sharp] Invalid parent process ID");
}
if (debug)
{
Debugger.Launch();
Console.WriteLine(@"""debug""");
}
else
{
Console.WriteLine(@"""ok""");
}
Console.WriteLine(@"null");
Console.Out.Flush();
if (parentProc != null)
{
Thread killswitch = new Thread(() => {
try {
while (!parentProc.HasExited && parentProc.Id == parentProcID)
{
Thread.Yield();
Thread.Sleep(1000);
}
Environment.Exit(0);
} catch {
Environment.Exit(-1);
}
})
{
Name = "Killswitch",
IsBackground = true
};
killswitch.Start();
}
Cmds.Init();
try {
while ((parentProc != null && !parentProc.HasExited && parentProc.Id == parentProcID) || parentProc == null)
{
TcpClient client = listener.AcceptTcpClient();
try {
string ep = client.Client.RemoteEndPoint.ToString();
Console.Error.WriteLine($"[sharp] New TCP connection: {ep}");
client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, 1000);
Stream stream = client.GetStream();
MessageContext ctx = new MessageContext();
lock (Cache)
foreach (Message msg in Cache.Values)
{
ctx.Reply(msg);
}
Thread threadW = new Thread(() => {
try {
using (StreamWriter writer = new StreamWriter(stream, UTF8NoBOM))
WriteLoop(parentProc, ctx, writer, verbose);
} catch (Exception e) {
if (e is ObjectDisposedException)
{
Console.Error.WriteLine($"[sharp] Failed writing to {ep}: {e.GetType()}: {e.Message}");
}
else
{
Console.Error.WriteLine($"[sharp] Failed writing to {ep}: {e}");
}
client.Close();
} finally {
ctx.Dispose();
}
})
{
Name = $"Write Thread for Connection {ep}",
IsBackground = true
};
Thread threadR = new Thread(() => {
try {
using (StreamReader reader = new StreamReader(stream, UTF8NoBOM))
ReadLoop(parentProc, ctx, reader, verbose);
} catch (Exception e) {
if (e is ObjectDisposedException)
{
Console.Error.WriteLine($"[sharp] Failed reading from {ep}: {e.GetType()}: {e.Message}");
}
else
{
Console.Error.WriteLine($"[sharp] Failed reading from {ep}: {e}");
}
client.Close();
} finally {
ctx.Dispose();
}
})
{
Name = $"Read Thread for Connection {ep}",
IsBackground = true
};
threads.Add(threadW);
threads.Add(threadR);
threadW.Start();
threadR.Start();
} catch (ThreadAbortException) {
} catch (Exception e) {
Console.Error.WriteLine($"[sharp] Failed listening for TCP connection:\n{e}");
client.Close();
}
}
} catch (ThreadAbortException) {
} catch (Exception e) {
Console.Error.WriteLine($"[sharp] Failed listening for TCP connection:\n{e}");
}
Console.Error.WriteLine("[sharp] Goodbye");
}
public override void HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey,
IBasicProperties properties, byte[] body)
{
Task.Run(async() =>
{
ExceptionDispatchInfo exception = null;
MessageContext context = null;
HandlingResult handlingResult = null;
try
{
try
{
context = new MessageContext
{
DependencyResolver = dependencyResolver,
Queue = queueName,
RoutingKey = routingKey,
Properties = properties
};
await DispatchMesage(context, body);
handlingResult = new HandlingResult
{
ConsumeResponse = ConsumeResponse.Ack,
MessageAction = MessageAction.None
};
}
catch (Exception eDispatch)
{
exception = ExceptionDispatchInfo.Capture(UnwrapException(eDispatch));
logger.HandlerException(eDispatch);
try
{
var exceptionStrategyContext = new ExceptionStrategyContext(context, exception.SourceException);
exceptionStrategy.HandleException(exceptionStrategyContext);
handlingResult = exceptionStrategyContext.HandlingResult.ToHandlingResult();
}
catch (Exception eStrategy)
{
logger.HandlerException(eStrategy);
}
}
try
{
if (handlingResult == null)
{
handlingResult = new HandlingResult
{
ConsumeResponse = ConsumeResponse.Nack,
MessageAction = MessageAction.None
};
}
await RunCleanup(context, handlingResult);
}
catch (Exception eCleanup)
{
logger.HandlerException(eCleanup);
}
}
finally
{
try
{
if (handlingResult == null)
{
handlingResult = new HandlingResult
{
ConsumeResponse = ConsumeResponse.Nack,
MessageAction = MessageAction.None
};
}
await worker.Respond(deliveryTag, handlingResult.ConsumeResponse);
}
catch (Exception eRespond)
{
logger.HandlerException(eRespond);
}
try
{
if (context != null)
{
context.Dispose();
}
}
catch (Exception eDispose)
{
logger.HandlerException(eDispose);
}
}
});
}
void DoTry()
{
var transportMessage = receiveMessages.ReceiveMessage(TransactionContext.Current);
if (transportMessage == null)
{
// to back off and relax then there's no messages to process, we do this
successiveNullMessagesReceived++;
var sleepTimeIndex = Math.Min(nullMessageSleepTimes.Length - 1, successiveNullMessagesReceived);
var timeToSleep = nullMessageSleepTimes[sleepTimeIndex];
Thread.Sleep(timeToSleep);
return;
}
successiveNullMessagesReceived = 0;
var id = transportMessage.Id;
var label = transportMessage.Label;
MessageContext context = null;
if (id == null)
{
HandlePoisonMessage(id, transportMessage);
return;
}
if (errorTracker.MessageHasFailedMaximumNumberOfTimes(id))
{
HandlePoisonMessage(id, transportMessage);
errorTracker.StopTracking(id);
return;
}
Exception transportMessageExceptionOrNull = null;
try
{
BeforeTransportMessage(transportMessage);
using (var scope = BeginTransaction())
{
var message = serializeMessages.Deserialize(transportMessage);
// successfully deserialized the transport message, let's enter a message context
context = MessageContext.Establish(message.Headers);
MessageContextEstablished(context);
var unitsOfWork = unitOfWorkManagers.Select(u => u.Create())
.Where(u => !ReferenceEquals(null, u))
.ToArray(); //< remember to invoke the chain here :)
try
{
foreach (var logicalMessage in message.Messages.Select(MutateIncoming))
{
context.SetLogicalMessage(logicalMessage);
Exception logicalMessageExceptionOrNull = null;
try
{
BeforeMessage(logicalMessage);
var typeToDispatch = logicalMessage.GetType();
log.Debug("Dispatching message {0}: {1}", id, typeToDispatch);
GetDispatchMethod(typeToDispatch)
.Invoke(this, new[] { logicalMessage });
}
catch (Exception exception)
{
logicalMessageExceptionOrNull = exception;
throw;
}
finally
{
try
{
AfterMessage(logicalMessageExceptionOrNull, logicalMessage);
}
catch (Exception exceptionWhileRaisingEvent)
{
if (logicalMessageExceptionOrNull != null)
{
log.Error(
"An exception occurred while raising the AfterMessage event, and an exception occurred some" +
" time before that as well. The first exception was this: {0}. And then, when raising the" +
" AfterMessage event (including the details of the first error), this exception occurred: {1}",
logicalMessageExceptionOrNull, exceptionWhileRaisingEvent);
}
else
{
log.Error("An exception occurred while raising the AfterMessage event: {0}",
exceptionWhileRaisingEvent);
}
}
context.ClearLogicalMessage();
}
}
foreach (var unitOfWork in unitsOfWork)
{
unitOfWork.Commit();
}
}
catch
{
foreach (var unitOfWork in unitsOfWork)
{
try
{
unitOfWork.Abort();
}
catch (Exception abortException)
{
log.Warn("An error occurred while aborting the unit of work {0}: {1}",
unitOfWork, abortException);
}
}
throw;
}
finally
{
foreach (var unitOfWork in unitsOfWork)
{
unitOfWork.Dispose();
}
}
if (scope != null)
{
scope.Complete();
}
}
}
catch (Exception exception)
{
transportMessageExceptionOrNull = exception;
log.Debug("Handling message {0} ({1}) has failed", label, id);
errorTracker.TrackDeliveryFail(id, exception);
throw;
}
finally
{
try
{
AfterTransportMessage(transportMessageExceptionOrNull, transportMessage);
}
catch (Exception exceptionWhileRaisingEvent)
{
if (transportMessageExceptionOrNull != null)
{
log.Error(
"An exception occurred while raising the AfterTransportMessage event, and an exception occurred some" +
" time before that as well. The first exception was this: {0}. And then, when raising the" +
" AfterTransportMessage event (including the details of the first error), this exception occurred: {1}",
transportMessageExceptionOrNull, exceptionWhileRaisingEvent);
}
else
{
log.Error("An exception occurred while raising the AfterTransportMessage event: {0}", exceptionWhileRaisingEvent);
}
}
if (context != null)
{
context.Dispose(); //< dispose it if we entered
}
}
errorTracker.StopTracking(id);
}
