void ConditionalRelay(IAppMessage Message) { if (allow(Message)) { Broker().Route(Message); } }
public CommandProcessExecutionLog(bool Executed = true, IAppMessage Message = null) { this.ErrorMessages = MutableList.Create <string>(); this.StatusMessages = MutableList.Create <string>(); this.Executed = Executed; this.AppMessage = Message ?? global::AppMessage.Empty; }
public static IAppMessage Combine(IAppMessage m1, IAppMessage m2) { if (Object.ReferenceEquals(m1, m2)) { return(m1); } var level = (EventLevel)Math.Min((int)m1.EventLevel, (int)m2.EventLevel); var template = "FIX ME" + m1.MessageTemplate + "\r\n" + m2.MessageTemplate; var ts = m1.Timestamp >= m2.Timestamp ? m1.Timestamp : m2.Timestamp; var content = new { Part1 = m1.SemanticContent, Part2 = m2.SemanticContent }; var state = new AppMessgaeState( Template: template, Content: content, Timestamp: ts, CorrelationToken: m2.CT, Level: level, MessageType: m2.MessageType ); return(new AppMessage(state)); }
/// <summary> /// Called whenever the router instance receives an appgram /// </summary> /// <param name="value">The appgram value</param> void IObserver <InboundAppgram> .OnNext(InboundAppgram value) { try { var segment = value.Segment; byte[] buffer = segment.Buffer; int offset = segment.Offset; int end = segment.End; if (offset >= end) { throw new Exception("Received appgram with no content"); } byte header = segment.Buffer[segment.Offset]; MessageType type = (MessageType)(header >> 4); IAppMessage message = _createMessage(type); offset = message.Deserialize(buffer, offset, end); InboundUnconfirmedRequest request = null; request = _processMessage(value, message, buffer, offset, end); if (request != null) { _unconfirmedRequestObservers.Next(request); } } catch (Exception ex) { Console.WriteLine(ex); } }
public static IAppMessage CommandCompletionError(ICommandResult result, IAppMessage CompletionMessage) => error("Successfully executed the @CommandName command but was unable to complete it: @CompletionError", new { result.Spec.CommandName, CompletionError = CompletionMessage.Format() });
public CommandResult(TSpec spec, object payload, bool succeeded, IAppMessage message, long subid, CorrelationToken?ct = null) { this.Spec = spec; this.Payload = payload; this.Succeeded = succeeded; this.Message = message; this.SubmissionId = subid; this.CorrelationToken = ct; }
public AgentNotification(SystemNodeIdentifier Host, SystemIdentifier System, AgentIdentifier Agent, ServiceAgentState State, IAppMessage Message) { this.Host = Host; this.System = System; this.Agent = Agent; this.State = State; this.Message = Message; }
public NotificationAppService( INotificationDefinitionManager notificationDefinitionManager, IUserNotificationManager userNotificationManager, INotificationSubscriptionManager notificationSubscriptionManager, IAppMessage notificationManager) { _notificationDefinitionManager = notificationDefinitionManager; _userNotificationManager = userNotificationManager; _notificationSubscriptionManager = notificationSubscriptionManager; _notificationManager = notificationManager; }
public void SendAppMessage(IAppMessage message) { var targetModule = this._moduleMgr.GetAppModule(message.TargetModule); if (targetModule.IsNull()) { return; } targetModule.ProcessRequest(message); //_appMsgQueue.Enqueue(message); }
public MoveTenantsToAnotherEditionJob( IRepository <Tenant> tenantRepository, EditionManager editionManager, IUnitOfWorkManager unitOfWorkManager, IAppMessage appMessage) { _tenantRepository = tenantRepository; _editionManager = editionManager; _unitOfWorkManager = unitOfWorkManager; _appMessage = appMessage; EventBus = NullEventBus.Instance; }
/// <summary> /// Sends a raw appgram /// </summary> /// <param name="address">The address of the destination device</param> /// <param name="expectingReply">True if a response is expected, false otherwise</param> /// <param name="message">The header message</param> /// <param name="content">The content of the appgram</param> internal void SendRaw(Address address, bool expectingReply, IAppMessage message, BufferSegment content) { lock (_lock) { OutboundAppgram appgram = new OutboundAppgram(); appgram.Content = new AppgramContent(message, content); appgram.Destination = address; appgram.ExpectingReply = expectingReply; appgram.Priority = NetgramPriority.Normal; if (_router != null) { _router.SendAppgram(appgram); } } }
/// <summary> /// Initializes a valued option with optional message content /// </summary> /// <param name="value">The encapsulated value</param> /// <param name="message">An optional message</param> public Option(T value, IAppMessage message = null) { if (value is IOption) { var o = value as IOption; this.Exists = o.IsSome; this.Message = message ?? o.Message ?? AppMessage.Empty; this.value = this.Exists ? (o.Value is T ? (T)o.Value : value) : default; } else { this.Exists = (value != null); this.value = value; this.Message = message ?? AppMessage.Empty; } }
/// <summary> /// Processes a received message /// </summary> /// <param name="appgram">The appgram that contains the received message</param> /// <param name="message">The message</param> /// <param name="buffer">The buffer containing the message content</param> /// <param name="offset">The start of the content within the buffer</param> /// <param name="end">The end of the content within the buffer</param> /// <returns>The inbound unconfirmed request to propagate, if any</returns> private InboundUnconfirmedRequest _processMessage(InboundAppgram appgram, IAppMessage message, byte[] buffer, int offset, int end) { var source = appgram.Source; var segment = new BufferSegment(buffer, offset, end); InboundUnconfirmedRequest request = null; switch (message.Type) { case MessageType.ConfirmedRequest: _txManager.ProcessConfirmedRequest(source, (ConfirmedRequestMessage)message, segment); break; case MessageType.UnconfirmedRequest: request = _processUnconfirmedRequest(appgram, (UnconfirmedRequestMessage)message, buffer, offset, end); break; case MessageType.SimpleAck: _txManager.ProcessSimpleAck(source, (SimpleAckMessage)message); break; case MessageType.ComplexAck: _txManager.ProcessComplexAck(source, (ComplexAckMessage)message, segment); break; case MessageType.SegmentAck: _txManager.ProcessSegmentAck(source, (SegmentAckMessage)message); break; case MessageType.Error: _txManager.ProcessError(source, (ErrorMessage)message); break; case MessageType.Reject: _txManager.ProcessReject(source, (RejectMessage)message); break; case MessageType.Abort: _txManager.ProcessAbort(source, (AbortMessage)message); break; } return(request); }
/// <summary> /// Formats the message for display /// </summary> /// <param name="message">The message to format</param> /// <param name="template">The template to apply</param> /// <param name="ts">Specifies whether timestamp should be prepended to message output</param> /// <param name="args">Valus used to populate template variables</param> /// <returns></returns> internal static string Format(IAppMessage message, string template, bool ts, params object[] args) { var argValues = from arg in args from m in TypedMessageDataMember.Get(arg.GetType()).Values let argName = m.Member.GetOptionalAttribute <DisplayNameAttribute>().MapValueOrDefault(a => a.DisplayName, m.Name) select new { ArgName = argName, ArgValue = m.GetValue(arg)?.ToString() ?? String.Empty }; var output = template; foreach (var argValue in argValues) { output = output.Replace($"$({argValue.ArgName})", argValue.ArgValue) .Replace($"@{argValue.ArgName}", argValue.ArgValue); } return((ts ? message.Timestamp.ToString() : string.Empty) + " " + output); }
public CorrelationToken?Route(IAppMessage message, bool immediate) { if (!RoutedMessages.TryAdd(message.MessageId, message.MessageId)) { return(message.CT); } Sentinel?.Invoke(message); foreach (var mtn in subscribers.Keys) { if (mtn == message.MessageType || mtn == nameof(IAppMessage)) { foreach (var subscriber in subscribers[mtn]) { subscriber.Observer(message); } } } return(message.CT); }
public ImportUsersToExcelJob( RoleManager roleManager, IUserListExcelDataReader userListExcelDataReader, IInvalidUserExporter invalidUserExporter, IUserPolicy userPolicy, IEnumerable <IPasswordValidator <User> > passwordValidators, IPasswordHasher <User> passwordHasher, ILocalizationManager localizationManager, IObjectMapper objectMapper, IDataFileObjectManager dataFileObjectManager, IAppMessage appMessage) { _roleManager = roleManager; _userListExcelDataReader = userListExcelDataReader; _invalidUserExporter = invalidUserExporter; _userPolicy = userPolicy; _passwordValidators = passwordValidators; _passwordHasher = passwordHasher; _objectMapper = objectMapper; _dataFileObjectManager = dataFileObjectManager; _appMessage = appMessage; _localizationSource = localizationManager.GetSource(AppConsts.LocalizationSourceName); }
public object ProcessRequest(IAppMessage request) { var key = request.Extensions[AppSystem.Message_Key]; if (!key.IsNull()) { if (key == AppSystem.Message_Navigation) { return(Navigation.Value); } } var report = request.Body.As <IReportViewModel>(); if (report == null) { return(request.Body); } else { report.Initialize(); return(report); } }
/// <summary> /// Creates a <see cref="Option{T}"/> with a value /// </summary> /// <typeparam name="T"></typeparam> /// <returns></returns> public static Option <T> some <T>(T value, IAppMessage message = null) => new Option <T>(value, message);
/// <summary> /// Creates a <see cref="Option{T}"/> with no value /// </summary> /// <typeparam name="T">The type of the optional value</typeparam> /// <returns></returns> public static Option <T> none <T>(IAppMessage message = null) => Option <T> .None(message ?? AppMessage.Empty);
/// <summary> /// Renders a message for display /// </summary> /// <param name="Message"></param> /// <param name="Orignator"></param> /// <returns></returns> public static string Format(this IAppMessage Message, SystemNodeIdentifier Orignator) { var tsFmt = Message.Timestamp.FormatTimestamp(); return(concat(tsFmt, " ", Orignator, "> ", Message.Format(false))); }
public FileWriteResult(FilePath DstPath, IAppMessage Message) : base(Message, DstPath) { this.DstPath = DstPath; }
public static FileWriteResult Failure(FilePath DstPath, IAppMessage Message) => new FileWriteResult(DstPath, Message);
public static FileWriteResult Success(FilePath DstPath, IAppMessage Message = null) => new FileWriteResult(DstPath, Message ?? AppMessage.Inform($"The {DstPath} file was successfully written"));
/// <summary> /// Populates a Some with optional message content /// </summary> /// <param name="Value">The encapsulated value</param> /// <param name="Message">The associated message</param> /// <returns></returns> public static Option <T> Some(T Value, IAppMessage Message = null) => new Option <T>(Value, Message ?? AppMessage.Empty);
internal static string Format(IAppMessage message, string prepend, string postpend, bool ts) => (!string.IsNullOrWhiteSpace(prepend) ? $"{prepend} {message.Format(false)}" : message.Format(ts)) + (!string.IsNullOrWhiteSpace(postpend) ? $" {postpend}" : String.Empty);
/// <summary> /// Returns some(message) if the message is nonemty; otherwise none /// </summary> /// <param name="message">The message to adjudicate</param> /// <returns></returns> public static Option <IAppMessage> ToOption(this IAppMessage message) => message == null?Option.None <IAppMessage>() : message.IsEmpty ? Option.None <IAppMessage>() : Option.Some(message);
public static bool IsWarning(this IAppMessage m) => m.EventLevel == EventLevel.Warning;
public static bool IsError(this IAppMessage m) => m.EventLevel == EventLevel.Error || m.EventLevel == EventLevel.Critical;
public static bool IsBabble(this IAppMessage m) => m.EventLevel == EventLevel.Verbose;
Option(bool isSome, T value, IAppMessage message) { this.Exists = isSome; this.value = value; this.Message = message ?? AppMessage.Empty; }