void CleanupDispatchedEnvelope(ImmutableEnvelope envelope)
{
try
{
_manager.Memorize(envelope.EnvelopeId);
}
catch (ThreadAbortException)
{
// continue;
throw;
}
catch (Exception ex)
{
SystemObserver.Notify(new EnvelopeCleanupFailed(ex,_dispatcherName, envelope));
}
try
{
_quarantine.TryRelease(envelope);
}
catch (ThreadAbortException)
{
// continue
throw;
}
catch (Exception ex)
{
SystemObserver.Notify(new EnvelopeCleanupFailed(ex, _dispatcherName, envelope));
}
SystemObserver.Notify(new EnvelopeDispatched(envelope,_dispatcherName));
}
void CleanupDispatchedEnvelope(ImmutableEnvelope envelope)
{
try
{
_manager.Memorize(envelope.EnvelopeId);
}
catch (ThreadAbortException)
{
// continue;
throw;
}
catch (Exception ex)
{
SystemObserver.Notify(new EnvelopeCleanupFailed(ex, _dispatcherName, envelope));
}
try
{
_quarantine.TryRelease(envelope);
}
catch (ThreadAbortException)
{
// continue
throw;
}
catch (Exception ex)
{
SystemObserver.Notify(new EnvelopeCleanupFailed(ex, _dispatcherName, envelope));
}
SystemObserver.Notify(new EnvelopeDispatched(envelope, _dispatcherName));
}
public static string PrintToString(this ImmutableEnvelope envelope, Func <object, string> serializer)
{
using (var writer = new StringWriter(CultureInfo.InvariantCulture))
{
writer.WriteLine("{0,12}: {1}", "EnvelopeId", envelope.EnvelopeId);
foreach (var attribute in envelope.Attributes)
{
writer.WriteLine("{0,12}: {1}", attribute.Key, attribute.Value);
}
writer.WriteLine(envelope.Message.GetType().Name);
try
{
var buffer = serializer(envelope.Message);
writer.WriteLine(buffer);
}
catch (Exception ex)
{
writer.WriteLine("Rendering failure");
writer.WriteLine(ex);
}
writer.WriteLine();
writer.Flush();
return(writer.GetStringBuilder().ToString());
}
}
public void PutMessage(ImmutableEnvelope envelope)
{
if (envelope.DeliverOnUtc < DateTime.UtcNow)
{
_target.PutMessage(_streamer.SaveEnvelopeData(envelope));
return;
}
// save to the store
var id = Interlocked.Increment(ref _universalCounter);
var fileName = string.Format("{0:yyyy-MM-dd-HH-mm-ss}-{1:00000000}-{2}.future",
envelope.DeliverOnUtc, id, _suffix);
// persist
var item = _storage.GetItem(fileName);
var data = _streamer.SaveEnvelopeData(envelope);
item.Write(x => x.Write(data, 0, data.Length));
// add to in-memory scheduler
lock (_scheduler)
{
_scheduler.Add(new Record(fileName, envelope.DeliverOnUtc));
}
}
public void TryRelease(ImmutableEnvelope context)
{
if (null != context)
{
int value;
_failures.TryRemove(context.EnvelopeId, out value);
}
}
public void TryRelease(ImmutableEnvelope context)
{
if (null != context)
{
int value;
_failures.TryRemove(context.EnvelopeId, out value);
}
}
public byte[] SaveEnvelopeData(ImmutableEnvelope envelope)
{
// string contract, Guid messageId, Uri sender,
var itemContracts = new MessageContract[envelope.Items.Length];
using (var content = new MemoryStream())
{
int position = 0;
for (int i = 0; i < envelope.Items.Length; i++)
{
var item = envelope.Items[i];
string name;
if (!_dataSerializer.TryGetContractNameByType(item.MappedType, out name))
{
var error = string.Format("Failed to find contract name to serialize '{0}'.", item.MappedType);
throw new InvalidOperationException(error);
}
// normal serializers have a nasty habbit of closing the stream after they are done
// we can suppress that or use a wrapper now instead
using (var itemStream = new MemoryStream())
{
_dataSerializer.Serialize(item.Content, item.MappedType, itemStream);
var bytes = itemStream.ToArray();
content.Write(bytes, 0, bytes.Length);
}
int size = (int)content.Position - position;
var attribContracts = EnvelopeConvert.ItemAttributesToContract(item.GetAllAttributes());
itemContracts[i] = new MessageContract(name, size, position, attribContracts);
position += size;
}
var envelopeAttribs = EnvelopeConvert.EnvelopeAttributesToContract(envelope.GetAllAttributes());
var contract = new EnvelopeContract(envelope.EnvelopeId, envelopeAttribs, itemContracts,
envelope.DeliverOnUtc, envelope.CreatedOnUtc);
using (var stream = new MemoryStream())
{
// skip header
stream.Seek(EnvelopeHeaderContract.FixedSize, SeekOrigin.Begin);
// save envelope attributes
_envelopeSerializer.SerializeEnvelope(stream, contract);
var envelopeBytes = stream.Position - EnvelopeHeaderContract.FixedSize;
// copy data
content.WriteTo(stream);
// write the header
stream.Seek(0, SeekOrigin.Begin);
var header = new EnvelopeHeaderContract(EnvelopeHeaderContract.Schema2DataFormat, envelopeBytes, 0);
header.WriteToStream(stream);
return(stream.ToArray());
}
}
}
public static string PrintToString(this ImmutableEnvelope envelope, Func <object, string> serializer)
{
using (var writer = new StringWriter(CultureInfo.InvariantCulture))
{
PrintTo(envelope, writer, serializer);
writer.Flush();
return(writer.GetStringBuilder().ToString());
}
}
public DomainLogDisplayItem(ImmutableEnvelope item, string session, long storeIndex)
{
Class = string.Join(",", item.Items.Select(s => s.MappedType.Name).ToArray());
Recorded = FormatUtil.TimeOffsetUtc(DateTime.SpecifyKind(item.CreatedOnUtc, DateTimeKind.Utc));
RecordId = item.EnvelopeId;
Item = item;
Session = session;
AssignStyle(item, session);
StoreIndex = storeIndex;
Type = ' ';
}
public bool TryToQuarantine(ImmutableEnvelope envelope, Exception ex)
{
// serialization problem
if (envelope == null)
return true;
var current = _failures.AddOrUpdate(envelope.EnvelopeId, s => 1, (s1, i) => i + 1);
if (current < 4)
{
return false;
}
// accept and forget
int forget;
_failures.TryRemove(envelope.EnvelopeId, out forget);
return true;
}
public static EnvelopeBuilder CloneProperties(string newId, ImmutableEnvelope envelope)
{
if (newId == envelope.EnvelopeId)
{
throw new InvalidOperationException("Envelope cloned for modification should have new identity.");
}
var builder = new EnvelopeBuilder(newId);
builder.OverrideCreatedOnUtc(envelope.CreatedOnUtc);
builder.DeliverOnUtc(envelope.DeliverOnUtc);
foreach (var attribute in envelope.GetAllAttributes())
{
builder.AddString(attribute.Key, attribute.Value);
}
return(builder);
}
public void Dispatch(byte[] message)
{
ImmutableEnvelope envelope = null;
try
{
envelope = _streamer.ReadAsEnvelopeData(message);
}
catch (Exception ex)
{
// permanent quarantine for serialization problems
_quarantine.Quarantine(message, ex);
SystemObserver.Notify(new EnvelopeDeserializationFailed(ex, "dispatch"));
return;
}
if (_manager.DoWeRemember(envelope.EnvelopeId))
{
SystemObserver.Notify(new EnvelopeDuplicateDiscarded(envelope.EnvelopeId));
return;
}
try
{
_action(envelope);
// non-essential but recommended
CleanupDispatchedEnvelope(envelope);
}
catch (ThreadAbortException)
{
return;
}
catch (Exception ex)
{
if (_quarantine.TryToQuarantine(envelope, ex))
{
SystemObserver.Notify(new EnvelopeQuarantined(ex, _dispatcherName, envelope));
// message quarantined. Swallow
return;
}
// if we are on a persistent queue, this will tell to retry
throw;
}
}
public byte[] SaveEnvelopeData(ImmutableEnvelope envelope)
{
using (var mem = new MemoryStream())
{
byte[] data;
using (var block = new MemoryStream())
{
MessageSerializer.WriteAttributes(envelope.Attributes, block);
MessageSerializer.WriteMessage(envelope.Message, envelope.Message.GetType(), block);
data = block.ToArray();
}
MessageSerializer.WriteCompactInt(Signature, mem);
StorageFramesEvil.WriteFrame(envelope.EnvelopeId, DateTime.UtcNow.Ticks, data, mem);
return(mem.ToArray());
}
}
public byte[] SaveEnvelopeData(ImmutableEnvelope envelope)
{
using (var mem = new MemoryStream())
{
byte[] data;
using (var block = new MemoryStream())
{
MessageSerializer.WriteAttributes(envelope.Attributes, block);
MessageSerializer.WriteMessage(envelope.Message, envelope.Message.GetType(), block);
data = block.ToArray();
}
MessageSerializer.WriteCompactInt(Signature, mem);
StorageFramesEvil.WriteFrame(envelope.EnvelopeId, envelope.CreatedUtc.Ticks, data, mem);
return mem.ToArray();
}
}
public bool TryToQuarantine(ImmutableEnvelope envelope, Exception ex)
{
// serialization problem
if (envelope == null)
{
return(true);
}
var current = _failures.AddOrUpdate(envelope.EnvelopeId, s => 1, (s1, i) => i + 1);
if (current < 4)
{
return(false);
}
// accept and forget
int forget;
_failures.TryRemove(envelope.EnvelopeId, out forget);
return(true);
}
public static void PrintTo(this ImmutableEnvelope envelope, TextWriter writer, Func <object, string> serializer)
{
//.AppendFormat("{0,12}: {1}", attribute.GetName(), attribute.GetValue())
writer.WriteLine(string.Format("{0,12}: {1}", "EnvelopeId", envelope.EnvelopeId));
writer.WriteLine(string.Format("{0,12}: {1:yyyy-MM-dd HH:mm:ss} (UTC)", "Created", envelope.CreatedOnUtc));
if (envelope.DeliverOnUtc != DateTime.MinValue)
{
writer.WriteLine(string.Format("{0,12}: {1:yyyy-MM-dd HH:mm:ss} (UTC)", "Deliver On",
envelope.DeliverOnUtc));
}
foreach (var attribute in envelope.GetAllAttributes())
{
writer.WriteLine(string.Format("{0,12}: {1}", attribute.Key, attribute.Value));
}
foreach (var message in envelope.Items)
{
writer.WriteLine();
writer.WriteLine("{0}. {1}", message.Index, message.MappedType);
foreach (var attribute in message.GetAllAttributes())
{
writer.WriteLine(string.Format("{0,12}: {1}", attribute.Key, attribute.Value));
}
try
{
var buffer = serializer(message.Content);
writer.WriteLine(buffer);
}
catch (Exception ex)
{
writer.WriteLine("Rendering failure");
writer.WriteLine(ex);
}
writer.WriteLine();
}
}
public static IEnumerable <ImmutableEnvelope> SelectMany(ImmutableEnvelope source)
{
if (source.Items.Length == 0)
{
yield break;
}
if (source.Items.Length == 1)
{
yield return(source);
yield break;
}
for (int si = 0; si < source.Items.Length; si++)
{
var id = source.EnvelopeId + "-s" + si;
yield return
(new ImmutableEnvelope(id, source.GetAllAttributes().ToArray(), new[] { source.Items[si] },
source.DeliverOnUtc, source.CreatedOnUtc));
}
}
public void SendEnvelope(ImmutableEnvelope envelope)
{
var queue = GetOutboundQueue();
var data = _streamer.SaveEnvelopeData(envelope);
if (Transaction.Current == null)
{
queue.PutMessage(data);
SystemObserver.Notify(new EnvelopeSent(queue.Name, envelope.EnvelopeId, false,
envelope.Items.Select(x => x.MappedType.Name).ToArray(), envelope.GetAllAttributes()));
}
else
{
var action = new CommitActionEnlistment(() =>
{
queue.PutMessage(data);
SystemObserver.Notify(new EnvelopeSent(queue.Name, envelope.EnvelopeId, true,
envelope.Items.Select(x => x.MappedType.Name).ToArray(), envelope.GetAllAttributes()));
});
Transaction.Current.EnlistVolatile(action, EnlistmentOptions.None);
}
}
public void SendEnvelope(ImmutableEnvelope envelope)
{
var queue = GetOutboundQueue();
var data = _streamer.SaveEnvelopeData(envelope);
if (Transaction.Current == null)
{
queue.PutMessage(data);
SystemObserver.Notify(new EnvelopeSent(queue.Name, envelope.EnvelopeId, false,
envelope.Items.Select(x => x.MappedType.Name).ToArray(), envelope.GetAllAttributes()));
}
else
{
var action = new CommitActionEnlistment(() =>
{
queue.PutMessage(data);
SystemObserver.Notify(new EnvelopeSent(queue.Name, envelope.EnvelopeId, true,
envelope.Items.Select(x => x.MappedType.Name).ToArray(), envelope.GetAllAttributes()));
});
Transaction.Current.EnlistVolatile(action, EnlistmentOptions.None);
}
}
void AssignStyle(ImmutableEnvelope item, string session)
{
Style += cell =>
{
if (session == (cell.Value as string))
{
cell.Style.BackColor = DomainAwareAnalysis.GetBackgroundColorForCategory(session);
}
else if (cell.Value is char)
{
cell.Style.BackColor = DomainAwareAnalysis.GetBackgroundColorForCategory(Class);
}
else
{
cell.Style.BackColor = DomainAwareAnalysis.GetBackgroundColorForContract(item.Items[0]);
}
};
}
public byte[] SaveEnvelopeData(ImmutableEnvelope envelope)
{
// string contract, Guid messageId, Uri sender,
var itemContracts = new MessageContract[envelope.Items.Length];
using (var content = new MemoryStream())
{
int position = 0;
for (int i = 0; i < envelope.Items.Length; i++)
{
var item = envelope.Items[i];
string name;
if (!_dataSerializer.TryGetContractNameByType(item.MappedType, out name))
{
var error = string.Format("Failed to find contract name to serialize '{0}'.", item.MappedType);
throw new InvalidOperationException(error);
}
// normal serializers have a nasty habbit of closing the stream after they are done
// we can suppress that or use a wrapper now instead
using (var itemStream = new MemoryStream())
{
_dataSerializer.Serialize(item.Content, item.MappedType, itemStream);
var bytes = itemStream.ToArray();
content.Write(bytes, 0, bytes.Length);
}
int size = (int) content.Position - position;
var attribContracts = EnvelopeConvert.ItemAttributesToContract(item.GetAllAttributes());
itemContracts[i] = new MessageContract(name, size, position, attribContracts);
position += size;
}
var envelopeAttribs = EnvelopeConvert.EnvelopeAttributesToContract(envelope.GetAllAttributes());
var contract = new EnvelopeContract(envelope.EnvelopeId, envelopeAttribs, itemContracts,
envelope.DeliverOnUtc, envelope.CreatedOnUtc);
using (var stream = new MemoryStream())
{
// skip header
stream.Seek(EnvelopeHeaderContract.FixedSize, SeekOrigin.Begin);
// save envelope attributes
_envelopeSerializer.SerializeEnvelope(stream, contract);
var envelopeBytes = stream.Position - EnvelopeHeaderContract.FixedSize;
// copy data
content.WriteTo(stream);
// write the header
stream.Seek(0, SeekOrigin.Begin);
var header = new EnvelopeHeaderContract(EnvelopeHeaderContract.Schema2DataFormat, envelopeBytes, 0);
header.WriteToStream(stream);
return stream.ToArray();
}
}
}
