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