private void CheckMessageConfirmedBy(IMessageModel confirmation) { if (confirmation is null) { throw new ArgumentNullException(nameof(confirmation)); } IMessageModel message; lock (_getNextMessageLock) message = GetMessageConfirmedBy(confirmation); using (_currentlyProcessingIdLock.Write()) _currentlyProcessingId = message is null ? string.Empty : message.Id; if (message is null) { Debug.WriteLine($"ConfirmationTimeoutChecker: confirmation {confirmation.Id} tried to confirm nonexistent message."); confirmation.Errors |= Errors.ConfirmedNonexistent; } else { message.IsConfirmed = true; if (IsTimeoutExceeded(message, confirmation)) { SetTimeoutError(message); OnTimeoutOccured(message); } _processedMessages.Add(message); } _processedConfirmations.Add(confirmation); using (_currentlyProcessingIdLock.Write()) _currentlyProcessingId = string.Empty; }
private void AssignIdIfNeeded(IMessageModel message) { if (string.IsNullOrWhiteSpace(message.Id)) { message.Id = _context.IdGenerator.GetNewID(); } }
public IMessageModel ClearFlagsIn(IMessageModel message) { _ = message ?? throw new System.ArgumentNullException(nameof(message)); message.Errors &= ~Errors.UndeterminedType; return(message); }
private bool CheckNextUnconfirmedMessage() { IMessageModel message = GetNextUnconfirmedMessage(); if (message is null) { return(false); } using (_currentlyProcessingIdLock.Read()) { if (_currentlyProcessingId == message.Id) { return(false); } else { ClearTimeoutError(message); if (IsTimeoutExceeded(message)) { HandleExceededTimeout(message); OnTimeoutOccured(message); return(true); } return(false); } } }
/// <summary> /// Sends a <see cref="IMessageModel"/> by pipeline. /// </summary> /// <param name="message"><see cref="IMessageModel"/> to be sent</param> /// <returns>True if <see cref="IMessageModel"/> sent successfully</returns> public async Task <bool> SendAsync(IMessageModel message) { message.Timestamp = Timestamp.TimestampNow; if (!CanSend(message)) { SendFailureHandler(message); return(false); } AssignIdIfNeeded(message); if (await _context.Messenger.SendAsync(message).ConfigureAwait(false)) { _sentMessages.TryAdd(message.Id, message); message.IsTransfered = true; if (!IsConfirmation(message)) { AddToConfirmationTimeoutChecking(message); OnMessageSent(message); } else { OnConfirmationSent(message); } return(true); } SendFailureHandler(message); return(false); }
public async Task Create(IMessageModel message) { await Task.Run(() => { message.Id = _nextId++; _messages.Add(message); }); }
private void HandleMessageTimeout(IMessageModel message) { if (message is null) { return; } MarkAsTimeoutAndComplete(message); }
public void AddToCheckingQueue(IMessageModel message) { if (message is null) { return; } lock (_getNextMessageLock) _storage.Add(message.Timestamp, message); }
private async Task SendConfirmationOfAsync(IMessageModel message) { IMessageModel confirmation = _context.ConfirmationFactory.GenerateConfirmationOf(message); if (await SendAsync(confirmation).ConfigureAwait(false)) { _sentMessages.TryAdd(confirmation.Id, confirmation); } }
public IMessageModel GenerateConfirmationOf(IMessageModel message) { if (message is null) { throw new ArgumentNullException(nameof(message), "ConfirmationFactory - GenerateConfirmationOf: Cannot create confirmation of NULL"); } IMessageModel confirmation = _messageFactory.CreateNew(Direction.Outgoing, MessageType.Confirmation, message.Id); confirmation.Add(_commandFactory.Create(CommandType.HandShake)); confirmation.Add(_commandFactory.Create(CommandType.Confirmation)); foreach (var c in message) { ICommandModel responseCommand = _commandFactory.Create(timestampOverride: confirmation.Timestamp); switch (c.CommandType) { case CommandType.Error: responseCommand.CommandType = CommandType.ReceivedAsError; break; case CommandType.Unknown: responseCommand.CommandType = CommandType.ReceivedAsUnknown; break; case CommandType.Partial: responseCommand.CommandType = CommandType.ReceivedAsPartial; break; default: responseCommand.CommandType = CommandType.ReceivedAsCorrect; break; } confirmation.Add(responseCommand); } if (message.Errors.HasFlag(Errors.CompletitionTimeout)) { confirmation.Add(_commandFactory.Create(CommandType.CompletitionTimeoutOccured)); } if (message.Errors.HasFlag(Errors.ConfirmationTimeout)) { confirmation.Add(_commandFactory.Create(CommandType.ConfirmationTimeoutOccurred)); } confirmation.Add(_commandFactory.Create(CommandType.EndMessage)); // Assigns id also to all commands inside confirmation.AssaignID(message.Id); confirmation.AssighHostID(_hostId); return(confirmation); }
public IMessageModel ClearFlagsIn(IMessageModel message) { _ = message ?? throw new ArgumentNullException(nameof(message)); ClearErrorFlag(Errors.GotUnknownCommands, message); ClearErrorFlag(Errors.GotErrorCommands, message); ClearErrorFlag(Errors.GotPartialCommands, message); return(message); }
public IMessageModel ClearFlagsIn(IMessageModel message) { _ = message ?? throw new ArgumentNullException(nameof(message)); if (message.Errors.HasFlag(Errors.BadMessagePattern)) { message.Errors &= ~Errors.BadMessagePattern; } return(message); }
public void AddConfirmation(IMessageModel confirmation) { if (confirmation is null) { return; } _confirmations.Add(confirmation.Id, confirmation); CheckMessageConfirmedBy(confirmation); }
public override async Task OnNavigatedToAsync(object parameter, NavigationMode mode, IDictionary <string, object> suspensionState) { IMessageModel model = parameter as IMessageModel; if (model != null) { SetModelMessage(model); } await Task.CompletedTask; }
public MainPresenter(IView view, IModelGemetic model, IFabricFileDocument modelSave, IMessageModel modelMessage) { _view = view ; _model = model ; _modelSave = modelSave; _modelMessage = modelMessage; _view.calculateEvent +=new EventHandler(_view_calculateEvent); _view.saveFileDocument +=new EventHandler(_view_saveFileDocument); _model.showProgress += new EventHandler(_model_showProgress); }
public async Task RetryFailedSends() { foreach (var kvp in _failedSendMessages) { IMessageModel message = kvp.Value; if (CanSend(message) && await SendAsync(message).ConfigureAwait(false)) { _failedSendMessages.TryRemove(kvp.Key, out _); } } }
public void AddMessage(IMessageModel message) { _repositories?.MessagesStore?.AddMessageItem(new MessageItem { UserName = message.UserName, Email = message.Email, Message = message.Message, SentDate = message.SentDate }); _repositories?.MessagesStore?.SaveMessages(); }
public IMessageModel CheckAndSetFlagsIn(IMessageModel message) { _message = ClearFlagsIn(message); _message.Type = DetectType(); if (_message.Type == MessageType.Unknown) { _message.Errors |= Errors.UndeterminedType; } return(_message); }
private IMessageModel CreateNewIncomingMessage(string id, ICommandModel commandToBaseOn) { if (string.IsNullOrWhiteSpace(id)) { throw new ArgumentException("Id cannot be empty", nameof(id)); } IMessageModel message = _msgFactory.CreateNew(direction: Enums.Direction.Incoming, id: id, timestampOverride: commandToBaseOn.TimeStamp, hostId: commandToBaseOn.HostId); _idGenerator.MarkAsUsedUp(id); return(message); }
public bool IsTimeoutExceeded(IMessageModel message, IMessageModel confirmation = null) { _ = message ?? throw new ArgumentNullException(nameof(message), "TimeoutChecker - Check: Cannot check timeout for NULL."); confirmation = confirmation is null?GetConfirmationOf(message) : null; bool isTimeoutExceeded = confirmation is null ? _timeoutCheck.IsExceeded(message) : _timeoutCheck.IsExceeded(message, confirmation); return(isTimeoutExceeded); }
public void PushFromIncompleteToProcessed(IMessageModel message) { _ = message ?? throw new ArgumentNullException(nameof(message)); lock (_processingLock) if (_incompleteMessages.TryRemove(message.Id, out IMessageModel transferedMessage)) { if (_completedMessages.TryAdd(transferedMessage.Id, transferedMessage)) { _processedMessages.Add(message); } } }
/// <summary> /// 执行命令消息 /// </summary> /// <param name="message"></param> public void ExecuteCommand(IMessageModel message) { Type commandType = null; List <IView> views = null; lock (m_syncRoot) { #region Sreach Command Line if (m_commandMap.ContainsKey(message.Name)) { commandType = m_commandMap[message.Name]; } else { views = new List <IView>(); foreach (KeyValuePair <IView, List <string> > keyValuePair in m_viewCommandMap) { if (keyValuePair.Value.Contains(message.Name)) { views.Add(keyValuePair.Key); } } } #endregion #region Command Line if (commandType != null) { object commandInstance = Activator.CreateInstance(commandType); ICommand command = commandInstance as ICommand; if (command != null) { command.Execute(message); } } #endregion #region Send View Message if (views != null && views.Count > 0) { int viewsCount = views.Count; for (int i = 0; i < viewsCount; i++) { IView view = views[i]; view.OnMessage(message); } views = null; } #endregion } }
public IMessageModel CheckAndSetFlagsIn(IMessageModel message) { _message = ClearFlagsIn(message); if (CheckPattern()) { return(_message); } else { _message.Errors |= Errors.BadMessagePattern; return(_message); } }
public async Task Create(IMessageModel message) { var p = new { message.ToName, message.FromName, message.MessageText, message.TimeCreated, message.LocationCreated, message.IsTestObject }; await _dataAccess.SaveData("dbo.spMessage_Create", p, "SQLDB"); }
public bool IsComplete(IMessageModel message) { _ = message ?? throw new ArgumentNullException(nameof(message)); if (message.IsCompleted) { return(true); } if (message.Count() >= 4 && IsSecondCommandAType(message.Commands[1].CommandType) && message.Last().CommandType == CommandType.EndMessage) { return(message.IsCompleted = true); } return(false); }
private void HandleExceededTimeout(IMessageModel message) { SetTimeoutError(message); if (GetConfirmationOf(message) is null) { SetNoConfirmatioError(message); } _processedMessages.Add(message); lock (_getNextMessageLock) if (_storage[_storage.Keys.First()].Timestamp == message.Timestamp) { _storage.Remove(_storage.Keys.First()); } _processingCTS.Token.ThrowIfCancellationRequested(); }
public IMessageModel CreateNew( Enums.Direction direction = Enums.Direction.Unknown, Enums.MessageType type = Enums.MessageType.Unknown, string idOverride = "", string hostIdOverride = "", long timestampOverride = 0) { IMessageModel output = _messageFactory(); output.AssaignID(string.IsNullOrWhiteSpace(idOverride) ? string.Empty : idOverride); output.AssighHostID(string.IsNullOrWhiteSpace(hostIdOverride)? string.Empty : hostIdOverride); output.Type = type; output.Direction = direction; output.Timestamp = timestampOverride < 0 ? Timestamp.TimestampNow : timestampOverride; return(output); }
public async Task <bool> SendAsync(IMessageModel message) { if (message is null) { return(false); } var results = new List <bool>(); foreach (ICommandModel c in message) { results.Add(await SendAsync(c).ConfigureAwait(false)); } return(results.Contains(false) ? false : true); }
public override void Execute(IMessageModel message) { //------------------------添加管理器对象----------------------------- AppBridgeLink.Instance.AddManager <NetWorkManager>(ManagerName.NET_WORK); //AppBridgeLink.Instance.AddManager<MusicManager>(ManagerName.MUSIC); AppBridgeLink.Instance.AddManager <TimerManager>(ManagerName.TIMER); //AppBridgeLink.Instance.AddManager<ImageCacheManager>(ManagerName.IMAGE_CACHE); AppBridgeLink.Instance.AddManager <NotificationManager>(ManagerName.NOTIFICATION); AppBridgeLink.Instance.AddManager <CoroutineManager>(ManagerName.COROUTINE); AppBridgeLink.Instance.AddManager <SceneManager>(ManagerName.SCENE); AppBridgeLink.Instance.AddManager <DataCacheManager>(ManagerName.DATACACHE); AppBridgeLink.Instance.AddManager <DownLoadManager>(ManagerName.DOWNLOAD); // AppBridgeLink.Instance.AddManager<DataStatisticsManager>(ManagerName.DATA_STATISTICS); AppBridgeLink.Instance.AddManager <AssetBundleManager>(ManagerName.ASSET_BUNDLE); // AppBridgeLink.Instance.AddManager<ImageTargetManager>(ManagerName.IMAGE_TARGET); //AppBridgeLink.Instance.AddManager<LanguagePackageManager>(ManagerName.LANGUAGE_PACKAGE); }
public void ParseLog(string search, IMessageModel messageModel) { if (search == null || messageModel == null) { return; } // [2017-05-20 19:04:51 UTC] xxxx: xxxx var text = string.Empty; foreach (var s in messageModel.UnEditedText) { if (s.ToLower().Contains(search.ToLower())) { text = text + $"{s}\n"; } } messageModel.Text = text; }
public async Task <bool> SendMessage(string SenderId, string RecipientId, IMessageModel Message) { if (Helpers.FullVerifyGuid(ref SenderId, logger) is false) { return(false); } if (Helpers.FullVerifyGuid(ref RecipientId, logger) is false) { return(false); } try { // get the serialized messages list var result = await db.ExecuteSingleProcedure <string, dynamic>(GetMessagesProcedure, new { Id = RecipientId }); // if the list is null just create a new one List <MessageModel> messages = result is null ? new() : Newtonsoft.Json.JsonConvert.DeserializeObject <List <MessageModel> >(result); // add it to the list if (Message is MessageModel mm) { // add the message if (messages.Contains(mm) is false) { messages.Add(mm); } } // serialize the list for storage result = Newtonsoft.Json.JsonConvert.SerializeObject(messages); // save the messages await db.ExecuteVoidProcedure <dynamic>(SetMessagesProcedure, new { Id = RecipientId, Messages = result }); return(true); } catch (Exception e) { logger.LogError("Failed to send message From {SenderId} to {RecipientId} Error: {Error}", SenderId, RecipientId, e); return(false); } }
public MessageCtrl(IMessageModel model) { Model = model; }
private void SetModelMessage(IMessageModel messageModel) { Header = messageModel.Header == null ? "" : messageModel.Header; UserSend = messageModel.UserSend == null ? "" : messageModel.UserSend; Content = messageModel.Content == null ? "" : messageModel.Content; }
public EmailService(EmailType EmailType, IMessageModel Message) { CurrEmailType = EmailType; this.Message = Message; }