private void PluginMessage(PluginMessage message, IAssemblyLoadContext assemblyLoadContext) { IPlugin plugin; if (_registeredPlugins.TryGetValue(message.PluginId, out plugin)) { try { plugin.ProcessMessage(message.Data, assemblyLoadContext); } catch (Exception exception) { OnError( message.PluginId, PluginMessageMessageName, errorMessage: Resources.FormatPlugin_EncounteredExceptionWhenProcessingPluginMessage( message.PluginId, exception.Message)); } } else { OnError( message.PluginId, PluginMessageMessageName, errorMessage: Resources.FormatPlugin_UnregisteredPluginIdCannotReceiveMessages(message.PluginId)); } }
public void Run(List <PluginSetting> Settings, out List <PluginMessage> Responses) { List <PluginMessage> pluginMessages = new List <PluginMessage>(); var checkedProcesses = CheckRunningProcesses.CheckProcess(Settings); if (checkedProcesses != null) { foreach (var i in checkedProcesses) { if (i.ProcessIsRunning) { PluginMessage message = new PluginMessage(); message.severity = Severities.Informational; message.facility = Facilities.log_audit; message.msg = i.Process.ProcessName + " operational."; pluginMessages.Add(message); } else { PluginMessage message = new PluginMessage(); message.severity = Severities.Emergency; message.facility = Facilities.kernel_messages; message.msg = i.ProcessToCheck + " not loaded."; pluginMessages.Add(message); } } } Responses = pluginMessages; }
public void Page_Load(object sender, EventArgs e) { MenuTabLabel.Text = BuildNavString(); PagePathLiteral.Text = BuildPagePath(); message = new PluginMessage(PluginType); Init(); }
public void ProcessMessages_RegisterPlugin_SendsPluginsProtocolWhenClientProtocolNotProvided() { var assemblyLoadContext = CreateTestAssemblyLoadContext <TestPlugin>(); var serviceProvider = new TestServiceProvider(); object rawWrappedData = null; var pluginHandler = new PluginHandler(serviceProvider, (data) => rawWrappedData = data); var pluginMessage = new PluginMessage { Data = new JObject { { "AssemblyName", "CustomAssembly" }, { "TypeName", typeof(TestPlugin).FullName }, }, MessageName = "RegisterPlugin", PluginId = RandomGuidId }; pluginHandler.OnReceive(pluginMessage); pluginHandler.ProcessMessages(assemblyLoadContext); var messageBrokerData = Assert.IsType <PluginMessageBroker.PluginMessageWrapperData>(rawWrappedData); Assert.Equal(RandomGuidId, messageBrokerData.PluginId); var responseMessage = Assert.IsType <RegisterPluginResponseMessage>(messageBrokerData.Data); Assert.True(responseMessage.Success); Assert.Equal("RegisterPlugin", responseMessage.MessageName, StringComparer.Ordinal); Assert.Equal(3, responseMessage.Protocol); }
public void ProcessMessages_RegisterPlugin_SendsErrorWhenUnableToLocatePluginType() { var assemblyLoadContext = CreateTestAssemblyLoadContext <TestPlugin>(); var serviceProvider = new TestServiceProvider(); object rawWrappedData = null; var pluginHandler = new PluginHandler(serviceProvider, (data) => rawWrappedData = data); var pluginMessage = new PluginMessage { Data = new JObject { { "AssemblyName", "CustomAssembly" }, { "TypeName", typeof(TestPlugin).FullName + "_" }, }, MessageName = "RegisterPlugin", PluginId = RandomGuidId }; var expectedErrorMessage = $"Could not locate plugin id '{RandomGuidId}' of type '{typeof(TestPlugin).FullName + "_"}' " + "in assembly 'CustomAssembly'."; pluginHandler.OnReceive(pluginMessage); pluginHandler.ProcessMessages(assemblyLoadContext); var messageBrokerData = Assert.IsType <PluginMessageBroker.PluginMessageWrapperData>(rawWrappedData); Assert.Equal(RandomGuidId, messageBrokerData.PluginId); var responseMessage = Assert.IsType <PluginResponseMessage>(messageBrokerData.Data); Assert.False(responseMessage.Success); Assert.Equal("RegisterPlugin", responseMessage.MessageName, StringComparer.Ordinal); Assert.Equal(expectedErrorMessage, responseMessage.Error, StringComparer.Ordinal); }
private void UnregisterMessage(PluginMessage message) { if (!_registeredPlugins.Remove(message.PluginId)) { var faultedRegistrationIndex = _faultedRegisterPluginMessages.FindIndex( faultedMessage => faultedMessage.PluginId == message.PluginId); if (faultedRegistrationIndex == -1) { OnError( message, errorMessage: Resources.FormatPlugin_UnregisteredPluginIdCannotUnregister(message.PluginId)); return; } else { _faultedRegisterPluginMessages.RemoveAt(faultedRegistrationIndex); } } SendMessage( message.PluginId, new PluginResponseMessage { MessageName = UnregisterPluginMessageName, }); }
public void ProcessMessages_UnregisterPlugin_SendsErrorWhenUnregisteringUnknownPlugin() { var assemblyLoadContext = CreateTestAssemblyLoadContext <TestPlugin>(); var serviceProvider = new TestServiceProvider(); object rawWrappedData = null; var pluginHandler = new PluginHandler(serviceProvider, (data) => rawWrappedData = data); var unregisterPluginMessage = new PluginMessage { MessageName = "UnregisterPlugin", PluginId = RandomGuidId }; var expectedErrorMessage = $"No plugin with id '{RandomGuidId}' has been registered. Cannot unregister plugin."; pluginHandler.OnReceive(unregisterPluginMessage); pluginHandler.ProcessMessages(assemblyLoadContext); var messageBrokerData = Assert.IsType <PluginMessageBroker.PluginMessageWrapperData>(rawWrappedData); Assert.Equal(RandomGuidId, messageBrokerData.PluginId); var responseMessage = Assert.IsType <PluginResponseMessage>(messageBrokerData.Data); Assert.False(responseMessage.Success); Assert.Equal("UnregisterPlugin", responseMessage.MessageName, StringComparer.Ordinal); Assert.Equal(expectedErrorMessage, responseMessage.Error, StringComparer.Ordinal); }
public void ProcessMessages_RegisterPlugin_SendsErrorOnInvalidPluginTypes() { var assemblyLoadContext = CreateTestAssemblyLoadContext <InvalidTestPlugin>(); var serviceProvider = new TestServiceProvider(); object rawWrappedData = null; var pluginHandler = new PluginHandler(serviceProvider, (data) => rawWrappedData = data); var pluginMessage = new PluginMessage { Data = new JObject { { "AssemblyName", "CustomAssembly" }, { "TypeName", typeof(InvalidTestPlugin).FullName }, }, MessageName = "RegisterPlugin", PluginId = RandomGuidId }; var expectedErrorMessage = $"Cannot process plugin message. Plugin id '{RandomGuidId}' of type " + "'Microsoft.Framework.DesignTimeHost.PluginHandlerFacts+InvalidTestPlugin' must be assignable " + "to type 'Microsoft.Framework.DesignTimeHost.IPlugin'."; pluginHandler.OnReceive(pluginMessage); pluginHandler.ProcessMessages(assemblyLoadContext); var messageBrokerData = Assert.IsType <PluginMessageBroker.PluginMessageWrapperData>(rawWrappedData); Assert.Equal(RandomGuidId, messageBrokerData.PluginId); var responseMessage = Assert.IsType <PluginResponseMessage>(messageBrokerData.Data); Assert.False(responseMessage.Success); Assert.Equal("RegisterPlugin", responseMessage.MessageName, StringComparer.Ordinal); Assert.Equal(expectedErrorMessage, responseMessage.Error, StringComparer.Ordinal); }
private void PluginMessage(PluginMessage message, IAssemblyLoadContext assemblyLoadContext) { IPlugin plugin; if (_registeredPlugins.TryGetValue(message.PluginId, out plugin)) { try { if (!plugin.ProcessMessage(message.Data, assemblyLoadContext)) { // Plugin didn't handle the message. Notify the client that we no-oped so it can respond // accordingly. OnNoop( message, Resources.FormatPlugin_PluginCouldNotHandleMessage(message.PluginId, message.MessageName)); } } catch (Exception exception) { OnError( message, errorMessage: Resources.FormatPlugin_EncounteredExceptionWhenProcessingPluginMessage( message.PluginId, exception.Message)); } } else { OnError( message, errorMessage: Resources.FormatPlugin_UnregisteredPluginIdCannotReceiveMessages(message.PluginId)); } }
public void ProcessMessages_RegisterPlugin_DoesNotCacheCreatedPlugin() { var assemblyLoadContext = CreateTestAssemblyLoadContext <CreationTestPlugin>(); var creationChecker = new PluginTypeCreationChecker(); var serviceLookups = new Dictionary <Type, object> { { typeof(PluginTypeCreationChecker), creationChecker } }; var serviceProvider = new TestServiceProvider(serviceLookups); var pluginHandler = new PluginHandler(serviceProvider, (_) => { }); var pluginMessage = new PluginMessage { Data = new JObject { { "AssemblyName", "CustomAssembly" }, { "TypeName", typeof(CreationTestPlugin).FullName }, }, MessageName = "RegisterPlugin", PluginId = RandomGuidId }; pluginHandler.OnReceive(pluginMessage); pluginHandler.ProcessMessages(assemblyLoadContext); Assert.True(creationChecker.Created); creationChecker.Created = false; pluginHandler.OnReceive(pluginMessage); pluginHandler.ProcessMessages(assemblyLoadContext); Assert.True(creationChecker.Created); }
public void ProcessMessages_PluginMessage_SendsErrorWhenPluginNotRegistered() { var assemblyLoadContext = CreateTestAssemblyLoadContext <TestPlugin>(); var serviceProvider = new TestServiceProvider(); object rawWrappedData = null; var pluginHandler = new PluginHandler(serviceProvider, (data) => rawWrappedData = data); var pluginMessage = new PluginMessage { Data = new JObject { { "Data", "Hello Plugin" }, }, MessageName = "PluginMessage", PluginId = RandomGuidId }; var expectedErrorMessage = $"Message received for unregistered plugin id '{RandomGuidId}'. Plugins must first be registered " + "before they can receive messages."; pluginHandler.OnReceive(pluginMessage); pluginHandler.ProcessMessages(assemblyLoadContext); var messageBrokerData = Assert.IsType <PluginMessageBroker.PluginMessageWrapperData>(rawWrappedData); Assert.Equal(RandomGuidId, messageBrokerData.PluginId); var responseMessage = Assert.IsType <PluginResponseMessage>(messageBrokerData.Data); Assert.False(responseMessage.Success); Assert.Equal("PluginMessage", responseMessage.MessageName, StringComparer.Ordinal); Assert.Equal(expectedErrorMessage, responseMessage.Error, StringComparer.Ordinal); }
private int GetCurrentRaceTimeMS(PluginMessage msg) { if (CurrentSessionStartTime == DateTime.MinValue) { return(0); } return((int)Math.Round((msg.CreationDate - CurrentSessionStartTime).TotalMilliseconds)); }
private void init() { message = new PluginMessage(PluginType); InstallButton.Visible = false; BackButton.Visible = false; Page.ClientScript.RegisterOnSubmitStatement(this.GetType(), "showProgress", "mask.showProgressBar();"); UploadButton.Text = "添加" + message.PluginLabel; }
public static void Log(PluginMessage msg) { if (_sLastCreatedLogviewer != null) { var entry = new PluginMessageEntry(msg); _sLastCreatedLogviewer.Append(entry); } }
/// <summary> Handles the ProcessCheck timer events</summary> /// <param name="source">The source.</param> /// <param name="e">The <see cref="ElapsedEventArgs"/> instance containing the event data.</param> public void ProcessCheckEvent(Object source, ElapsedEventArgs e) { int countersToFix = 0; if (lastTimerEvent == new DateTime()) { lastTimerEvent = DateTime.Now; } else { double currentLatency = DateTime.Now.Subtract(lastTimerEvent).TotalMilliseconds; timerLatency += currentLatency; //LogToConsole(currentLatency.ToString()); if (timerLatency > 10000) { var newcounters = (timerLatency - (timerLatency % 10000)) / 10000; countersToFix = int.Parse(newcounters.ToString()); //LogToConsole("Timer: Adjusting clock by " + countersToFix + " ticks for latency of " + timerLatency); timerLatency = timerLatency - (10000 * countersToFix); } lastTimerEvent = DateTime.Now; } //LogToConsole("Timer triggered : " + DateTime.Now.ToRfc3339String()); // check each plugin for settings foreach (var plugin in Plugins) { if (countersToFix > 0) { plugin.SecondsSinceLastEvent += countersToFix; } if (plugin.SecondsSinceLastEvent > plugin.TimeUntilEvent) { PluginMessage pluginMessage = new PluginMessage(); var thisProc = new ProcessPluginThread(plugin, this); Thread thisThread = new Thread( new ThreadStart( thisProc.Process ) ); thisThread.Start(); LogToConsole(" - Processing plugin event for :" + plugin.Name); //thisThread.Join(); plugin.SecondsSinceLastEvent = 0; } else { plugin.SecondsSinceLastEvent += 1; } } return; }
protected void Page_Load(object sender, EventArgs e) { message = new PluginMessage(PluginType); helper = new PluginHelper(PluginType); if (!IsPostBack) { DataBind(); } }
public void TryRegisterFaultedPlugins_RecoversFaultedPluginRegistrations() { var pluginType = typeof(MessageBrokerCreationTestPlugin); var typeNameLookups = new Dictionary <string, Type> { { pluginType.FullName, pluginType } }; var testAssembly = new TestAssembly(typeNameLookups); var assemblyLookups = new Dictionary <string, Assembly> { { "CustomAssembly", testAssembly } }; var assemblyLoadContext = new FailureAssemblyLoadContext(assemblyLookups); var creationChecker = new PluginTypeCreationChecker(); var serviceLookups = new Dictionary <Type, object> { { typeof(PluginTypeCreationChecker), creationChecker } }; var serviceProvider = new TestServiceProvider(serviceLookups); object rawMessageBrokerData = null; var pluginHandler = new PluginHandler(serviceProvider, (data) => rawMessageBrokerData = data); var registerPluginMessage = new PluginMessage { Data = new JObject { { "AssemblyName", "CustomAssembly" }, { "TypeName", typeof(MessageBrokerCreationTestPlugin).FullName }, }, MessageName = "RegisterPlugin", PluginId = RandomGuidId }; pluginHandler.OnReceive(registerPluginMessage); pluginHandler.ProcessMessages(assemblyLoadContext); var messageBrokerData = Assert.IsType <PluginMessageBroker.PluginMessageWrapperData>(rawMessageBrokerData); Assert.Equal(RandomGuidId, messageBrokerData.PluginId); var responseMessage = Assert.IsType <RegisterPluginResponseMessage>(messageBrokerData.Data); Assert.False(responseMessage.Success); Assert.Equal("RegisterPlugin", responseMessage.MessageName, StringComparer.Ordinal); Assert.NotEmpty(responseMessage.Error); Assert.False(creationChecker.Created); pluginHandler.TryRegisterFaultedPlugins(assemblyLoadContext); messageBrokerData = Assert.IsType <PluginMessageBroker.PluginMessageWrapperData>(rawMessageBrokerData); Assert.Equal(RandomGuidId, messageBrokerData.PluginId); responseMessage = Assert.IsType <RegisterPluginResponseMessage>(messageBrokerData.Data); Assert.True(responseMessage.Success); Assert.Equal("RegisterPlugin", responseMessage.MessageName, StringComparer.Ordinal); Assert.Equal(1, responseMessage.Protocol); Assert.Null(responseMessage.Error); Assert.True(creationChecker.Created); }
protected void Page_Load(object sender, EventArgs e) { Message = new PluginMessage(PluginType); if (!IsPostBack) { } InitPage(); refresh.Click += new EventHandler(refresh_Click); }
/// <summary> /// Converts a ChangedItem to a protal cache message /// </summary> /// <param name="changedItem">ChangedItem to convert</param> /// <param name="entityRecordMessage">EntityRecordMessage with the corresponding entityName</param> /// <returns>Portal cache message converted from ChangedItem</returns> private PluginMessage CreateMessageForRemovedOrDeletedItem(RemovedOrDeletedItem changedItem, EntityRecordMessage entityRecordMessage) { if (changedItem == null) { return(null); } PluginMessage message; AssociateDisassociateMessage associateDisassociateMessage = entityRecordMessage as AssociateDisassociateMessage; ADXTrace.Instance.TraceWarning(TraceCategory.Application, string.Format("Converting ChangedItem/Deleted with EntityName: {0} and Type:{1} to Portal Cache Message", changedItem.RemovedItem.LogicalName, changedItem.Type.ToString())); if (associateDisassociateMessage == null || changedItem.RemovedItem.LogicalName == "adx_webpageaccesscontrolrule_webrole") { message = new PluginMessage { MessageName = Constants.RemovedOrDeleted, Target = new PluginMessageEntityReference { Name = null, Id = changedItem.RemovedItem.Id, LogicalName = changedItem.RemovedItem.LogicalName, }, }; } else { message = new PluginMessage { MessageName = Constants.Disassociate, Target = new PluginMessageEntityReference { // Special Handling : We want this information to pass to adx code for dissociate and message schema is fixed / nothing can be added, this name/guid would have been null/empty else . Name = associateDisassociateMessage.EntityName, Id = changedItem.RemovedItem.Id, LogicalName = associateDisassociateMessage.RelatedEntity1Name, }, RelatedEntities = new List <PluginMessageEntityReference> { new PluginMessageEntityReference { Name = null, Id = Guid.Empty, LogicalName = associateDisassociateMessage.RelatedEntity2Name, } }, Relationship = new PluginMessageRelationship { PrimaryEntityRole = null, SchemaName = associateDisassociateMessage.RelationshipName, }, }; } return(message); }
private void OnError(PluginMessage requestMessage, string errorMessage) { SendMessage( requestMessage.PluginId, message: new PluginResponseMessage { MessageId = requestMessage.MessageId, MessageName = requestMessage.MessageName, Error = errorMessage, }); }
private PluginMessage GetLogParsePluginMessage(string message, bool isError) { var pluginMessage = new PluginMessage(); var logType = isError ? LogType.Error : LogType.StandardOutput; pluginMessage.LogParseMessage = new LogParseMessage() { LogType = logType, Message = message }; return(pluginMessage); }
private void RegisterMessage(PluginMessage message, IAssemblyLoadContext assemblyLoadContext) { var response = RegisterPlugin(message, assemblyLoadContext); if (!response.Success) { _faultedRegisterPluginMessages.Add(message); } SendMessage(message.PluginId, response); }
protected override async Task PostAsync(IOwinContext context, PluginMessage message) { var restartMessage = new ApplicationRestartPortalBusMessage(); if (restartMessage.Validate(message)) { ADXTrace.Instance.TraceInfo(TraceCategory.Application, string.Format("Post: name={0}", message.Target.Name)); await PortalBusManager <ApplicationRestartPortalBusMessage> .PostAsync(context, new ApplicationRestartPortalBusMessage()).WithCurrentCulture(); } }
/// <summary> /// Implementation of handling send method defined proto /// It handles the request based on <see cref="PluginMessage.PayloadCase" /> /// </summary> /// <param name="request"></param> /// <param name="context"></param> /// <returns></returns> public override Task <PluginMessageResponse> Send(PluginMessage request, ServerCallContext context) { switch (request.PayloadCase) { case PluginMessage.PayloadOneofCase.LogParseMessage: return(HandleLogParse(request.LogParseMessage)); default: return(HandleUnknown()); } }
public PluginHandlerOnReceiveResult OnReceive([NotNull] PluginMessage message) { _messageQueue.Enqueue(message); if (message.MessageName == RegisterPluginMessageName) { return(PluginHandlerOnReceiveResult.RefreshDependencies); } return(PluginHandlerOnReceiveResult.Default); }
/// <inheritdoc /> public virtual RemoteTask <object> OnMessage(PluginMessage msg, params object[] parameters) { switch (msg) { case PluginMessage.OnLoggerConfigUpdated: return(OnLoggerConfigUpdated()); default: LogTo.Debug($"Received unknown message {msg}. Is plugin up to date ?"); break; } return(Task.FromResult <object>(null)); }
/// <nodoc /> public virtual async Task <PluginResponseResult <List <PluginMessageType> > > GetSupportedPluginMessageType() { var requestId = GetRequestId(); var options = GetCallOptions(requestId); var request = new PluginMessage(); var response = await HandleRpcExceptionWithCallAsync( async() => { var response = await PluginServiceClient.SupportedOperationAsync(request, options); return(response.SupportedOperationResponse.Operation.Select(op => PluginMessageTypeHelper.ToPluginMessageType(op)).ToList()); }, requestId); return(response); }
public override void OnPluginMessage(BotShell bot, PluginMessage message) { try { if (message.Command != "announce") { return; } if (message.Args.Length < 3) { return; } string group = (string)message.Args[0]; if (group == null || group == string.Empty) { return; } string source = (string)message.Args[1]; if (source == null || source == string.Empty) { return; } string sender = (string)message.Args[2]; if (sender == null || sender == string.Empty) { return; } string msg = (string)message.Args[3]; if (msg == null || msg == string.Empty) { return; } string formattedMessage = bot.ColorHighlight + "Message from " + HTML.CreateColorString(bot.ColorHeaderHex, sender) + " on " + HTML.CreateColorString(bot.ColorHeaderHex, source) + " »» " + bot.ColorNormal + msg; string[] members = this._friendsList.GetOnlineMembers(group, true); bot.SendPrivateMessage(sender, bot.ColorHighlight + "Sending out an announcement to " + HTML.CreateColorString(bot.ColorHeaderHex, members.Length.ToString()) + " members"); foreach (string member in members) { bot.SendPrivateMessage(bot.GetUserID(member), formattedMessage, AoLib.Net.PacketQueue.Priority.Low, true); } members = this._friendsList.GetOnlineMembers(group, false); bot.SendReplyMessage(this.InternalName, message, (object)members); } catch (Exception ex) { Console.WriteLine(ex.ToString()); throw new Exception("exception", ex); } }
/// <nodoc /> public virtual async Task <PluginResponseResult <bool> > StopAsync() { var requestId = GetRequestId(); var options = GetCallOptions(requestId); var request = new PluginMessage(); var response = await HandleRpcExceptionWithCallAsync( async() => { var response = await PluginServiceClient.StopAsync(request, options); return(response.Status); }, requestId); return(response); }
private void OnNoop(PluginMessage requestMessage, string errorMessage) { // We only want to send a no-op message if there's an associated message id on the request message. if (requestMessage.MessageId != null) { SendMessage( requestMessage.PluginId, message: new NoopPluginResponseMessage { MessageId = requestMessage.MessageId, MessageName = requestMessage.MessageName, Error = errorMessage }); } }
public DefaultPlugin(IPluginInfo info, PluginOperate load, PluginOperate unload, PluginTestSuccessFlag isSuccessFlag, PluginMessage getMsg) { if (info == null) ArgumentNull.Throw("info"); if (load == null) ArgumentNull.Throw("load"); if (unload == null) ArgumentNull.Throw("unload"); if (isSuccessFlag == null) ArgumentNull.Throw("isSuccessFlag"); if (getMsg == null) ArgumentNull.Throw("getMsg"); this.Info = info; this.load = load; this.unload = unload; this.isSuccessFlag = isSuccessFlag; this.msg = getMsg; }