/// <summary>
/// Reads an EDI item from the stream.
/// An EDI item is an IEdiControl or a message or a ParsingException.
/// </summary>
/// <returns>Indication if an item was read.</returns>
public bool Read()
{
Item = null;
try
{
while ((!StreamReader.EndOfStream || Buffer.Any()) && Item == null)
{
ProcessSegment(ReadSegment());
if (Separators != null)
{
continue;
}
Item = new ParsingException(ErrorCodes.InvalidControlStructure, "No valid interchange header was found.");
}
}
catch (ParsingException ex)
{
Item = ex;
}
catch (Exception ex)
{
Item = new ParsingException(ErrorCodes.Unknown, ex.Message, ex);
}
if (StreamReader.EndOfStream && CurrentMessage.Any())
{
Item = new ParsingException(ErrorCodes.ImproperEndOfFile, "Unprocessed segments before the end of file.");
CurrentMessage.Clear();
}
return(Item != null);
}
public void Perform_a_large_request_response_pool()
{
const int repeatCount = 20000;
int responsesReceived = 0;
ManualResetEvent completed = new ManualResetEvent(false);
LocalBus.Subscribe <PingMessage>(x => CurrentMessage.Respond(new PongMessage(x.CorrelationId)));
LocalBus.Subscribe <PongMessage>(x =>
{
if (Interlocked.Increment(ref responsesReceived) == repeatCount)
{
completed.Set();
}
});
Thread.Sleep(3.Seconds());
Stopwatch stopwatch = Stopwatch.StartNew();
for (int index = 0; index < repeatCount; index++)
{
LocalBus.Publish(new PingMessage());
}
bool success = completed.WaitOne(60.Seconds(), true);
stopwatch.Stop();
Trace.WriteLine(string.Format("Elapsed Time for {0} messages = {1}", repeatCount * 2, stopwatch.Elapsed));
Trace.WriteLine(string.Format("Messages Per Second = {0}", repeatCount * 2000 / stopwatch.ElapsedMilliseconds));
}
public static DataEventAction <T, TData> RetryLater <T, TData>(this DataEventAction <T, TData> eventAction)
where T : SagaStateMachine <T>, ISaga
where TData : class
{
eventAction.Call((saga, message) => CurrentMessage.RetryLater());
return(eventAction);
}
public void The_retry_count_should_be_set_on_the_message()
{
FutureMessage <PingMessage> future = new FutureMessage <PingMessage>();
bool first = true;
LocalBus.Subscribe <PingMessage>(message =>
{
if (first)
{
Assert.AreEqual(0, CurrentMessage.Headers.RetryCount);
CurrentMessage.RetryLater();
first = false;
}
else
{
Assert.AreEqual(1, CurrentMessage.Headers.RetryCount);
future.Set(message);
}
});
LocalBus.Publish(new PingMessage());
Assert.IsTrue(future.IsAvailable(5.Seconds()));
}
void EditMessageCore(bool sendMessage, bool closeWindow)
{
if (isCopyOfCurrentMessage)
{
CurrentMessage.Assign(NewMessage);
NewMessage = CurrentMessage;
}
NewMessage.Type = sendMessage ? MessageType.Sent : MessageType.Draft;
NewMessage.NormalizeEmails();
if (!Items.Contains(NewMessage))
{
Items.Add(NewMessage);
if (!sendMessage)
{
NewMessage.IsUnread = true;
UpdateMailUnreadCount(mailFolders);
}
}
UpdateItemsSource();
NewMessage = null;
if (closeWindow)
{
this.GetService <IWindowService>().Close();
}
}
/// <summary>
/// Tries to parse what had been collected before a new message starts.
/// </summary>
/// <param name="segmentContext">The current segment.</param>
/// <param name="tag">The start new message tag.</param>
/// <returns>If flushed.</returns>
internal bool Flush(SegmentContext segmentContext, SegmentTags tag)
{
if ((segmentContext.IsControl || segmentContext.Tag == tag) && CurrentMessage.Any())
{
foreach (var c in segmentContext.Value)
{
Buffer.Enqueue(c);
}
Buffer.Enqueue(Separators.Segment);
try
{
if (CurrentGroupHeader != null)
{
CurrentMessage.Add(CurrentGroupHeader);
}
Item = CurrentMessage.Analyze(Separators, BuildContext());
}
finally
{
CurrentMessage.Clear();
}
return(true);
}
return(false);
}
internal override MessageContext BuildContext()
{
var unh = CurrentMessage.SingleOrDefault(es => es.Tag == SegmentId.UNH);
if (unh == null)
{
throw new ParsingException(ErrorCodes.InvalidInterchangeContent, "UNH was not found.");
}
var ediCompositeDataElements = unh.Value.GetDataElements(Separators);
if (ediCompositeDataElements.Count() < 2)
{
throw new ParsingException(ErrorCodes.InvalidInterchangeContent,
"UNH is invalid. Too little data elements.", unh.Value);
}
var ediDataElements = ediCompositeDataElements[1].GetComponentDataElements(Separators);
if (ediDataElements.Count() < 3)
{
throw new ParsingException(ErrorCodes.InvalidInterchangeContent,
"UNH is invalid. Unable to read message type or version.", unh.Value);
}
var tag = ediDataElements[0];
var version = ediDataElements[1] + ediDataElements[2];
var controlNumber = ediCompositeDataElements[0];
return(new MessageContext(tag, controlNumber, version, "Edifact", RulesAssembly, RulesNamespacePrefix));
}
private void ThreadedLoad()
{
try {
item.LoadDetails();
ThreadAssist.ProxyToMain(delegate {
ClearMessages();
if (item.Details != null)
{
gui.Contents.UpdateDetails();
}
});
} catch (Exception e) {
Log.Error("Error loading IA item details", e);
ThreadAssist.ProxyToMain(delegate {
var web_e = e as System.Net.WebException;
if (web_e != null && web_e.Status == System.Net.WebExceptionStatus.Timeout)
{
SetStatus(Catalog.GetString("Timed out getting item details from the Internet Archive"), true);
CurrentMessage.AddAction(new MessageAction(Catalog.GetString("Try Again"), (o, a) => Load()));
}
else
{
SetStatus(Catalog.GetString("Error getting item details from the Internet Archive"), true);
}
});
}
}
internal override MessageContext BuildContext()
{
if (CurrentGroupHeader == null)
{
throw new ParsingException(ErrorCodes.InvalidInterchangeContent, "GS was not found.");
}
var ediCompositeDataElementsGs = CurrentGroupHeader.Value.GetDataElements(Separators);
if (ediCompositeDataElementsGs.Count() < 8)
{
throw new ParsingException(ErrorCodes.InvalidInterchangeContent, "GS is invalid. Too little data elements.");
}
var version = ediCompositeDataElementsGs[7];
var st = CurrentMessage.SingleOrDefault(es => es.Tag == SegmentTags.ST);
if (st == null)
{
throw new ParsingException(ErrorCodes.InvalidInterchangeContent, "ST was not found.");
}
var ediCompositeDataElementsSt = st.Value.GetDataElements(Separators);
var tag = ediCompositeDataElementsSt[0];
if (ediCompositeDataElementsSt.Count() == 3)
{
version = ediCompositeDataElementsSt[2];
}
if (ediCompositeDataElementsSt.Count() < 2)
{
throw new ParsingException(ErrorCodes.InvalidInterchangeContent, "ST is invalid.Too little data elements.");
}
var controlNumber = ediCompositeDataElementsSt[1];
return(new MessageContext(tag, controlNumber, version, "X12", RulesAssemblyName, RulesNamespacePrefix));
}
public void A_response_should_be_sent_directly_if_a_reply_address_is_specified()
{
PingMessage ping = new PingMessage();
TestMessageConsumer <PongMessage> otherConsumer = new TestMessageConsumer <PongMessage>();
RemoteBus.Subscribe(otherConsumer);
TestCorrelatedConsumer <PongMessage, Guid> consumer = new TestCorrelatedConsumer <PongMessage, Guid>(ping.CorrelationId);
LocalBus.Subscribe(consumer);
FutureMessage <PongMessage> pong = new FutureMessage <PongMessage>();
RemoteBus.Subscribe <PingMessage>(message =>
{
pong.Set(new PongMessage(message.CorrelationId));
CurrentMessage.Respond(pong.Message);
});
LocalBus.Publish(ping, context => context.SendResponseTo(LocalBus));
Assert.IsTrue(pong.IsAvailable(3.Seconds()), "No pong generated");
consumer.ShouldHaveReceivedMessage(pong.Message, 3.Seconds());
otherConsumer.ShouldNotHaveReceivedMessage(pong.Message, 1.Seconds());
}
public static DataEventAction <T, TData> RespondWith <T, TData, TMessage>(this DataEventAction <T, TData> eventAction, Func <T, TData, TMessage> action)
where T : SagaStateMachine <T>, ISaga
where TData : class
where TMessage : class
{
eventAction.Call((saga, message) => CurrentMessage.Respond(action(saga, message)));
return(eventAction);
}
/// <summary>
/// Adds text to the current message
/// </summary>
public void AddTextToMessage(string text)
{
if (!string.IsNullOrEmpty(text))
{
var txt_bytes = Encoding.ASCII.GetBytes(text).ToList();
CurrentMessage.AddRange(txt_bytes);
NotifyPropertyChanged("CurrentMessage");
}
}
public void SetMessage(MessageView mv)
{
if (CurrentMessage != null)
{
CurrentMessage.ClearContents();
}
stackMessage.Clear();
UpdateCurrentMessage(mv);
}
public void A_pong_service()
{
PingService = new ConsumerOf <Ping>(ping =>
{
// Response with a pong to the ping
CurrentMessage.Respond(new Pong(ping.CorrelationId));
});
RemoteBus.Subscribe(PingService);
}
internal override void ProcessSegment(string segment)
{
if (string.IsNullOrEmpty(segment) || Separators == null)
{
return;
}
var segmentContext = new SegmentContext(segment, Separators);
if (Flush(segmentContext, SegmentId.UNH))
{
return;
}
switch (segmentContext.Tag)
{
case SegmentId.UNA:
break;
case SegmentId.UNB:
Item = segmentContext.Value.ParseSegment <S_UNB>(Separators);
break;
case SegmentId.UNG:
Item = segmentContext.Value.ParseSegment <S_UNG>(Separators);
break;
case SegmentId.UNH:
CurrentMessage.Add(segmentContext);
break;
case SegmentId.UNT:
try
{
CurrentMessage.Add(segmentContext);
Item = CurrentMessage.Analyze(Separators, BuildContext());
}
finally
{
CurrentMessage.Clear();
}
break;
case SegmentId.UNE:
Item = segmentContext.Value.ParseSegment <S_UNE>(Separators);
break;
case SegmentId.UNZ:
Item = segmentContext.Value.ParseSegment <S_UNZ>(Separators);
break;
default:
CurrentMessage.Add(segmentContext);
break;
}
}
private static Action <FirstCommand> FirstCommandConsumer(FirstCommand message)
{
return(command =>
{
ThreadUtil.Sleep(10.Milliseconds());
var response = new FirstResponse(command.CorrelationId);
CurrentMessage.Respond(response);
});
}
private void lineRemoveButton_Click(object sender, EventArgs e)
{
int line = lineNum.SelectedIndex;
CurrentMessage.RemoveAt(line);
if (line == CurrentMessage.Count)
{
--line;
}
UpdateLineSelect();
lineNum.SelectedIndex = line;
}
/// <summary>
/// Sends the current message across the serial line
/// </summary>
public void SendCurrentMessage()
{
lock (_serial_port_lock)
{
if (_serial_port != null && _serial_port.IsOpen)
{
_serial_port.Write(CurrentMessage.ToArray(), 0, CurrentMessage.Count);
}
}
CurrentMessage.Clear();
NotifyPropertyChanged("CurrentMessage");
}
public override int GetHashCode()
{
unchecked
{
var hashCode = Id.GetHashCode();
hashCode = (hashCode * 397) ^ (Description != null ? Description.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (int)State;
hashCode = (hashCode * 397) ^ StartTime.GetHashCode();
hashCode = (hashCode * 397) ^ FinishTime.GetHashCode();
hashCode = (hashCode * 397) ^ (Result != null ? Result.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (CurrentMessage != null ? CurrentMessage.GetHashCode() : 0);
return(hashCode);
}
}
private bool ValidateCurrentMessage()
{
if (!string.IsNullOrWhiteSpace(CurrentMessage.RoutingKey))
{
return(true);
}
else
{
CurrentLog.Error(CurrentMessage, $"Message without routing key has been received. Skipping it. Processor #{_id}.");
CurrentMessage.Ack();
return(false);
}
}
public override Task SendAsync(ArraySegment <byte> buffer, WebSocketMessageType messageType, bool endOfMessage,
CancellationToken cancellationToken)
{
if (buffer.Array != null)
{
CurrentMessage.Write(buffer.Array, buffer.Offset, buffer.Count);
}
if (endOfMessage)
{
Messages.Add(CurrentMessage);
CurrentMessage = new ChunkedMemoryStream();
}
return(Task.CompletedTask);
}
public void Consume(SendOrderDetailsRequest request)
{
// simulate a call to the external service
ThreadUtil.Sleep(1.Seconds());
var details = new OrderDetailsResponse
{
OrderId = request.OrderId,
CustomerId = request.CustomerId,
Created = (-1).Days().FromUtcNow(),
Status = OrderStatus.InProcess,
};
CurrentMessage.Respond(details, x => x.ExpiresAt(5.Minutes().FromNow()));
}
private void DeleteMessage(object sender, ExecutedRoutedEventArgs e)
{
if (CurrentMessage != null)
{
CurrentMessage.SetDeleted(true);
}
NextMessage(sender, null);
if (CurrentMessage == null)
{
// Didn't have a next message.
Close();
}
}
private void ProcessNewOrder(NewOrderMessage message)
{
_name = message.Name;
_item = message.Item;
_size = message.Size;
_amount = GetPriceForSize(_size);
Console.WriteLine(string.Format("I've received an order for a {0} {1} for {2}.", _size, _item, _name));
var paymentDueMessage = new PaymentDueMessage
{
CorrelationId = message.CorrelationId,
Amount = _amount,
};
CurrentMessage.Respond(paymentDueMessage);
}
public void Consume(T message)
{
WorkerDetails worker = _selectionStrategy.GetAvailableWorkers(_workers.Values, message, false).FirstOrDefault();
if (worker == null)
{
CurrentMessage.RetryLater();
return;
}
worker.Add();
IEndpoint endpoint = _endpointFactory.GetEndpoint(worker.DataUri);
var distributed = new Distributed <T>(message, CurrentMessage.Headers.ResponseAddress);
endpoint.Send(distributed);
}
public static bool ProcessSingleMessage(
CurrentMessageInformation currentMessageInformation,
Func <CurrentMessageInformation, bool> messageRecieved)
{
if (messageRecieved == null)
{
return(false);
}
foreach (Func <CurrentMessageInformation, bool> func in messageRecieved.GetInvocationList())
{
using (CurrentMessage.Track(currentMessageInformation))
if (func(currentMessageInformation))
{
return(true);
}
}
return(false);
}
private async Task ProcessMessageAsync(
IMessageSubscription subscription,
EnvelopedMessage envelopedMessage,
object payload,
MessageHeaders headers)
{
var publisher = _repliesPublisher?.Invoke(headers.CorrelationId)
?? ProhibitedRepliesMessagePublisher.Instance;
var handlingContext = new MessageHandlingContext
(
envelopedMessage.Exchange,
envelopedMessage.RetryCount,
envelopedMessage.RoutingKey
);
var result = await subscription.InvokeHandlerAsync(_serviceProvider, payload, headers, handlingContext, publisher);
if (result == null)
{
throw new InvalidOperationException("Result should be not null");
}
switch (result)
{
case MessageHandlingResult.SuccessResult _:
case MessageHandlingResult.NonTransientFailureResult _:
CurrentMessage.Ack();
break;
case MessageHandlingResult.TransientFailureResult tfr:
_retryManager.ScheduleRetry(CurrentMessage, tfr.RetryAfter ?? _defaultRetryTimeout);
break;
default:
throw new NotSupportedException($"Unexpected message handling result [{result.GetType().Name}].");
}
}
/// <summary>
/// Parses a text string for bytes the user would like to add to the current message
/// Bytes should be separated by spaces.
/// If a byte starts with "0x", it will be parsed as a hexidecimal value.
/// Otherwise, it will be parsed as a decimal value.
/// </summary>
public void AddBytesToMessage(string text)
{
if (!string.IsNullOrEmpty(text))
{
var string_pieces = text.Split(new char[] { ' ' }).ToList();
if (string_pieces.Count > 0)
{
for (int i = 0; i < string_pieces.Count; i++)
{
var this_piece = string_pieces[i];
if (this_piece.StartsWith("0x", StringComparison.CurrentCultureIgnoreCase))
{
//Parse as a hexidecimal value
this_piece = this_piece.Substring(2);
bool hex_parsed_successfully = Byte.TryParse(this_piece,
NumberStyles.HexNumber, CultureInfo.CurrentCulture, out byte hex_result);
if (hex_parsed_successfully)
{
CurrentMessage.Add(hex_result);
}
}
else
{
//Parse as a decimal value
bool decimal_parsed_successfully = Byte.TryParse(this_piece, out byte decimal_result);
if (decimal_parsed_successfully)
{
CurrentMessage.Add(decimal_result);
}
}
}
NotifyPropertyChanged("CurrentMessage");
}
}
}
private async Task <List <CurrentMessage> > GetMessagesPartsAsync(List <Message> messages, GmailService service)
{
List <CurrentMessage> messagesInfo = new List <CurrentMessage>();
if (messages != null)
{
foreach (var msg in messages)
{
UsersResource.MessagesResource.GetRequest emailInfoRequest = service.Users.Messages.Get("me", msg.Id);
var emailInfoResponse = await emailInfoRequest.ExecuteAsync();
if (emailInfoResponse != null)
{
CurrentMessage currentMsg = new CurrentMessage();
foreach (var mParts in emailInfoResponse.Payload.Headers)
{
currentMsg.Id = msg.Id;
if (mParts.Name == "Date")
{
currentMsg.Date = mParts.Value;
}
else if (mParts.Name == "From")
{
currentMsg.From = mParts.Value;
}
else if (mParts.Name == "Subject")
{
currentMsg.Subject = mParts.Value;
}
}
messagesInfo.Add(currentMsg);
}
}
}
return(messagesInfo);
}
public static void Bootstrap()
{
var bus = ObjectFactory.GetInstance <IServiceBus>();
bus.Subscribe <OrderDetailRequestActor>();
bus.Subscribe <RetrieveOrderDetails>(message =>
{
var details = new OrderDetailsReceivedImpl(message.CustomerId, message.OrderId, SystemUtil.Now, OrderStatus.Accepted);
// TODO
// impl builder
// var message = BuildImpl<ODR>(x =>
// { x.Set(y => y.CustomerId, customerId)
// }
CurrentMessage.Respond(details);
});
PipelineViewer.Trace(bus.InboundPipeline);
}
