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 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); } }
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(); } } }