private void HandleDeadletter(DeadLetter dl)
{
Console.WriteLine("Something getting Worng.. Please restart your Program");
Console.WriteLine($"DeadLetter captured: {dl.Message}, sender: {dl.Sender}, recipient: {dl.Recipient}");
Context.Stop(Self);
startgame();
}
//TODO: Since this isn't overriding SendUserMessage it doesn't handle all messages as Akka JVM does
protected override void HandleDeadLetter(DeadLetter deadLetter)
{
if (!SpecialHandle(deadLetter.Message, deadLetter.Sender))
{
_eventStream.Publish(deadLetter);
}
}
public async Task <DeadLetter> GetDeadLetterAsync(int id)
{
DeadLetter deadLetter = new DeadLetter();
await Task.Run(() => { deadLetter = GetDeadLetter(id); });
return(deadLetter);
}
private async Task <IEnumerable <DeadLetter> > ReadDeadLettersFromServiceBusAsync(string serviceBusQueue)
{
ConcurrentBag <DeadLetter> _deadLetters = new ConcurrentBag <DeadLetter>();
IMessageReceiver messageReceiver = _messageReceiverFactory.Create(serviceBusQueue, ReceiveMode.PeekLock, true);
IList <Message> messages = await messageReceiver.PeekAsync(MaxMessageCount);
await messageReceiver.CloseAsync();
foreach (Message message in messages)
{
// Process the message
var deadletter = new DeadLetter(_messageReader.ReadMessage(Encoding.UTF8.GetString(message.Body)))
{
MessageDate = message.SystemProperties.EnqueuedTimeUtc,
DeadLetterReason = message.UserProperties["DeadLetterReason"].ToString(),
DeadLetterErrorDescription = message.UserProperties["DeadLetterErrorDescription"].ToString(),
SequenceNumber = message.SystemProperties.SequenceNumber,
SubscriptionName = serviceBusQueue
};
_deadLetters.Add(deadletter);
}
return(_deadLetters);
}
// 서버 접속이 안될 때(Dead Letter 메시지를 받을 때)
private void Handle(DeadLetter data)
{
_logger.Info("The server is not connected");
_logger.Info(data.ToString());
if (File.Exists(@"../../Recipe/Recipe.txt"))
{
if (recipeRead == false)
{
_logger.Info("The recipe exists.");
StreamReader RecipeRead;
RecipeRead = File.OpenText(@"../../Recipe/Recipe.txt");
string RecipeData = RecipeRead.ReadToEnd();
monitoringTime = Convert.ToInt32(RecipeData);
_logger.Info("Read the recipe.");
nonScheduler = Context.System.Scheduler.ScheduleTellRepeatedlyCancelable(
0,
monitoringTime,
Self,
new Monitoring(),
Self);
recipeRead = true;
}
else
{
_logger.Info("Recipe information is available.");
}
}
else
{
_logger.Info("The recipe does not exist.");
}
Thread.Sleep((int)appSettings.GetValue("RetryServerConnectTime", typeof(int)));
Self.Tell(new RetryToSubscribeMonitorLocal());
serverAccessState = false;
}
private void SetRetry(Channel channel, IDictionary <string, object> argumentDictionary)
{
#region 错误队列
var deadLetter = new DeadLetter()
{
Exchange = $"{Exchange.Name}@failed",
RoutingKey = $"{RoutingKey}",
Queue = $"{Queue.Name}@failed"
};
channel.CurrentChannel.ExchangeDeclare(deadLetter.Exchange, ExchangeTypeEnum.Direct.ToString().ToLower(), durable: true, autoDelete: false);
channel.CurrentChannel.QueueDeclare(deadLetter.Queue, durable: true, exclusive: false, autoDelete: false, arguments: null);
channel.CurrentChannel.QueueBind(deadLetter.Queue, deadLetter.Exchange, deadLetter.RoutingKey, null);
#endregion
#region 重试队列
IDictionary <string, object> retryArgumentDictionary = new Dictionary <string, object>();
retryArgumentDictionary.Add("x-dead-letter-exchange", Exchange.Name);
retryArgumentDictionary.Add("x-dead-letter-routing-key", RoutingKey);
retryArgumentDictionary.Add("x-message-ttl", 30 * 1000);
channel.CurrentChannel.ExchangeDeclare($"{Exchange.Name}@retry", ExchangeTypeEnum.Direct.ToString().ToLower(), durable: true, autoDelete: false);
channel.CurrentChannel.QueueDeclare($"{Queue.Name}@retry", durable: true, exclusive: false, autoDelete: false, arguments: retryArgumentDictionary);
channel.CurrentChannel.QueueBind($"{Queue.Name}@retry", $"{Exchange.Name}@retry", deadLetter.RoutingKey, null);
#endregion
#region 主队列
channel.CurrentChannel.QueueDeclare(Queue.Name, durable: Queue.Durable, exclusive: Queue.Exclusive, autoDelete: Queue.AutoDelete, arguments: !argumentDictionary.Any() ? null : argumentDictionary);
#endregion
}
private SqlParameter[] GetParameters(DeadLetter deadLetter)
{
SqlParameter[] parameters = new SqlParameter[2];
parameters[0] = new SqlParameter("@Body", deadLetter.Body.Replace("'", "").Replace("\"", ""));
parameters[1] = new SqlParameter("@Message", deadLetter.Message.Replace("'", "").Replace("\"", ""));
return(parameters);
}
private void Handle(DeadLetter deadLetter)
{
var msg = $"message: {deadLetter.Message}, \n" +
$"sender: {deadLetter.Sender}, \n" +
$"recipient: {deadLetter.Recipient}\n";
Console.WriteLine(msg);
}
private void HandleDeadletter(DeadLetter dl)
{
if (dl.Message.GetType().Name == "AdvanceTo")
{
return;
}
//TODO Throw unhandled messages ?
_logger.Log(LogLevel.Trace, message: $"DeadLetter captured: {dl.Message}, sender: {dl.Sender}, recipient: {dl.Recipient}");
}
private void HandleDeadletter(DeadLetter dl)
{
if (dl.Message.GetType().Name == "AdvanceTo")
{
return;
}
//TODO Throw unhandled messages ?
System.Diagnostics.Debug.WriteLine(message: $"DeadLetter captured: {dl.Message}, sender: {dl.Sender}, recipient: {dl.Recipient}");
}
protected bool Handle(DeadLetter deadLetter)
{
if (!(deadLetter.Message is TCommand) || deadLetter.Message.GetPropertyValue("AggregateId")?.GetType() != typeof(TIdentity))
{
return(true);
}
ReDispatch((TCommand)deadLetter.Message);
return(true);
}
protected bool Handle(DeadLetter deadLetter)
{
if (deadLetter.Message is TCommand &&
(deadLetter.Message as dynamic).AggregateId.GetType() == typeof(TIdentity))
{
var command = deadLetter.Message as dynamic;
ReDispatch(command);
}
return(true);
}
private void HandleDeadletter(DeadLetter dl)
{
string message = dl.Message.ToString();
bool value;
if (bool.TryParse(message, out value) && value)
{
return;
}
Logger.LogWarning("Akka delivery failed", dl.Recipient.Path.ToString(), new Exception(dl.Message.ToString()), metaData: new Dictionary <string, object> {
{ "Sender", dl.Sender }
});
}
public void TerminateRootServer(DeadLetter terminateServerMsg)
{
foreach (var client in _managerOfClients)
{
client.Value.AssignedClientActor.Tell(new MessageOfTerminatedServer());
}
_managerOfClients.Clear();
_clientsCount = 0;
_deletedClientIDStock.Clear();
Console.WriteLine("Server를 종료합니다");
}
private void SetDeadLetter(Channel channel, IDictionary <string, object> argumentDictionary)
{
var deadLetterConfig = new DeadLetter()
{
Exchange = $"{Exchange.Name}@failed",
RoutingKey = $"{RoutingKey}",
Queue = $"{Queue.Name}@failed"
};
channel.CurrentChannel.ExchangeDeclare(deadLetterConfig.Exchange, ExchangeTypeEnum.Direct.ToString().ToLower(), durable: true, autoDelete: false);
channel.CurrentChannel.QueueDeclare(deadLetterConfig.Queue, durable: true, exclusive: false, autoDelete: false, arguments: null);
channel.CurrentChannel.QueueBind(deadLetterConfig.Queue, deadLetterConfig.Exchange, deadLetterConfig.RoutingKey, null);
argumentDictionary.Add("x-dead-letter-exchange", deadLetterConfig.Exchange);
argumentDictionary.Add("x-dead-letter-routing-key", deadLetterConfig.RoutingKey);
channel.CurrentChannel.QueueDeclare(Queue.Name, durable: Queue.Durable, exclusive: Queue.Exclusive, autoDelete: Queue.AutoDelete, arguments: argumentDictionary);
}
public void Handle(DeadLetter letter)
{
Thread.Sleep(MainApplication._configureInfo.RetryServerConnectTime * 1000);
try
{
_actorWpfSystem.ServerActor = _actorWpfSystem.ActorSystem.ActorSelection
(MainApplication._configureInfo.GetConfigure()).
ResolveOne(TimeSpan.Zero).Result;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return;
}
RetryToSubscribeClient();
}
public DeadLetter GetDeadLetter(int id)
{
DeadLetter deadLetter = new DeadLetter();
SqlParameter[] parameters = new SqlParameter[1];
parameters[0] = new SqlParameter("@Id", id);
using (SqlDataReader reader = _Context.ReturnDataReader("proc_DeadLetter_Get", parameters))
{
while (reader.Read())
{
deadLetter = PopulateDeadLetter(reader);
}
reader.Close();
}
return(deadLetter);
}
/// <summary>
/// Handles DeadLetters for workflow
/// </summary>
/// <param name="dl"></param>
private void DeadLetterMessageHandler(DeadLetter dl)
{
Console.WriteLine($"DeadLetter captured: {dl.Message}, sender: {dl.Sender}, recipient: {dl.Recipient}");
ReadOnlyCollection <(string Name, ActorPath ActorPath)> recipientList = WorkflowUtilities.DetermineRecipient(dl.Recipient);
if (recipientList.Count == 0)
{
Console.WriteLine($"{GetType().Name} deadletter has odd empty actorPath so ignoring it");
}
else if (recipientList.Count > 0 && recipientList[0].ActorPath.Parent.Equals("system"))
{
Console.WriteLine($"{GetType().Name} deadletter is a system deadletter so ignoring it");
}
else
{
Context.ActorSelection(recipientList[0].ActorPath).Tell(new DeadletterHandlingMessage(recipientList, dl.Message), ActorRefs.NoSender);
}
}
public void Handle(DeadLetter deadLetter)
{
if (!_actor.IsStopped)
{
Action <IDeadLettersListener> consumer = x => x.Handle(deadLetter);
if (_mailbox.IsPreallocated)
{
_mailbox.Send(_actor, consumer, null, "Handle(DeadLetter)");
}
else
{
_mailbox.Send(new LocalMessage <IDeadLettersListener>(_actor, consumer, "Handle(DeadLetter)"));
}
}
else
{
_actor.DeadLetters?.FailedDelivery(new DeadLetter(_actor, "Handle(DeadLetter)"));
}
}
private void LogDeadLetter(DeadLetter message)
{
var sb = new StringBuilder();
sb.AppendLine();
sb.AppendLine("DeadLetter encountered:");
if (message.Sender != null)
{
sb.AppendFormat("* Sender: {0}", message.Sender.Path);
}
else
{
sb.Append("* Sender: null");
}
sb.AppendLine();
if (message.Recipient != null)
{
sb.AppendFormat("* Receiver: {0}", message.Recipient.Path);
}
else
{
sb.Append("* Receiver: null");
}
sb.AppendLine();
if (message.Message != null)
{
sb.AppendFormat("* Message type: {0}", message.Message.GetType().FullName);
}
else
{
sb.Append("* Message: null");
}
_logger.Warn(sb.ToString());
}
private void HandleDeadLetter(DeadLetter message)
{
var msg = message.Message;
var rcp = message.Recipient;
var snd = message.Sender;
if (!(msg is Terminate))
{
var recipientPath = rcp.Path.ToString();
var recipientType = rcp.GetType();
var warning = new Warning(recipientPath, recipientType, message);
if (!ShouldFilter(warning))
{
var msgStr = (msg is ISystemMessage)
? "Received dead system message: " + msg
: "Received dead letter from " + snd + ": " + msg;
var warning2 = new Warning(recipientPath, recipientType, new DeadLetter(msgStr, snd, rcp));
if (!ShouldFilter(warning2))
{
Print(warning2);
}
}
}
}
public void Handle(DeadLetter terminateServerMsg)
{
_managerOfClients.Clear();
_clientsCount = 0;
_deletedClientIDStock.Clear();
}
public async Task CreateDeadLetterAsync(DeadLetter deadLetter)
{
await PostAsync <DeadLetter>("/api/v1/deadLetter/create", deadLetter);
}
public async Task CreateDeadLetterAsync(DeadLetter deadLetter)
{
await Task.Run(() => { _Context.ExecuteProc("proc_DeadLetter_Create", GetParameters(deadLetter)); });
}
private void HandleDeadletter(DeadLetter dl)
{
Console.WriteLine($"DeadLetter captured: {dl.Message}, sender: {dl.Sender}, recipient: {dl.Recipient}");
}
private static async Task RunAsync()
{
int loadedCount = 0;
int deadLetterCount = 0;
IClientAsyncRepository clientRepository = new ClientApiRepository(_clientApiUrl);
IStockAsyncRepository stockRepository = new StockApiRepository(_stockApiUrl);
ITradeAsyncRepository tradeRepository = new TradeApiRepository(_tradeApiUrl);
IDeadLetterAsyncRepository letterRepository = new DeadLetterApiRepository(_tradeApiUrl);
// Open Feed
IJsonFeed feed = new JsonMock.JsonFeed();
if (feed.Status != IJsonFeed.StatusCode.Ok)
{
Console.WriteLine("*** Trade Feed could not be opened ***");
Console.WriteLine(feed.Error);
return;
}
// Read Json Data
List <TradeFeed> trades = feed.GetTradeFeedData();
if (feed.Status != IJsonFeed.StatusCode.Ok)
{
Console.WriteLine("*** Trade Feed could not be processed - trades added to dead letter queue ***");
Console.WriteLine(feed.Error);
DeadLetter dl = new DeadLetter()
{
Body = feed.DeadLetter,
Message = feed.Error
};
await letterRepository.CreateDeadLetterAsync(dl);
return;
}
// Process Json Data
foreach (TradeFeed trade in trades)
{
string error = ValidateTrade(trade);
if (!string.IsNullOrEmpty(error))
{
DeadLetter dlr = new DeadLetter()
{
Body = JsonConvert.SerializeObject(trade),
Message = error
};
await letterRepository.CreateDeadLetterAsync(dlr);
deadLetterCount++;
}
else
{
//Check if Stock Exists and add if not
Stock stock = await stockRepository.GetStockAsync(Int32.Parse(trade.StockId));
if (string.IsNullOrEmpty(stock.Name))
{
stock.Id = Int32.Parse(trade.StockId);
stock.Name = trade.StockName;
stock.Type = trade.StockType;
await stockRepository.CreateStockAsync(stock);
}
//Check if Client exists and add if not
Client client = await clientRepository.GetClientAsync(Int32.Parse(trade.ClientId));
if (string.IsNullOrEmpty(client.Name))
{
client.Id = Int32.Parse(trade.ClientId);
client.Name = trade.ClientName;
await clientRepository.CreateClientAsync(client);
}
Trade tr = new Trade()
{
StockId = Int32.Parse(trade.StockId),
ClientId = Int32.Parse(trade.ClientId),
Venue = trade.VenueName,
Quantity = Int32.Parse(trade.Quantity),
Price = decimal.Parse(trade.Price),
BuySell = trade.BuySell.ToUpper()
};
await tradeRepository.CreateTradeAsync(tr);
loadedCount++;
}
}
Console.WriteLine("Finished Processing Feed, {0} trades added, {1} dead letters added", loadedCount.ToString(), deadLetterCount.ToString());
}
public void Handle(DeadLetter deadLetter) => result.AddDeadLetter(deadLetter);
protected virtual void HandleDeadLetter(DeadLetter deadLetter)
{
SpecialHandle(deadLetter.Message, deadLetter.Sender);
}
public void Handle(DeadLetter deadLetter)
{
result.deadLetters.Add(deadLetter);
result.until.Happened();
}
private void HandleDeadletter(DeadLetter dl)
{
Logger.LogDebug($"DeadLetter captured: {dl.Message}, sender: {dl.Sender}, recipient: {dl.Recipient}");
}
