public static Growl.Destinations.DestinationSettingsPanel GetSettingsPanel(Subscription s) { ISubscriptionHandler handler = GetHandler(s); Growl.Destinations.DestinationSettingsPanel panel = handler.GetSettingsPanel(s); return(panel); }
private static void LoadFolder(string folder) { try { if (!loadedPlugins.ContainsKey(folder)) { PluginFinder pf = new PluginFinder(); ISubscriptionHandler plugin = pf.Search <ISubscriptionHandler>(folder, CheckType, ignoreList); if (plugin != null) { Type type = plugin.GetType(); PluginInfo pi = new PluginInfo(folder, type); LoadPlugin(pi, plugin); } } } catch (Exception ex) { // suppress any per-plugin loading exceptions Utility.WriteDebugInfo(String.Format("Plugin failed to load: '{0}' - {1} - {2}", folder, ex.Message, ex.StackTrace)); } }
public IEnumerable <ISubscriptionHandler> GetHandlers(ModifiedFileModel modifiedFile) { List <ISubscriptionHandler> subscriptionHandlers = new List <ISubscriptionHandler>(); HandlerResolver resolver = new HandlerResolver(this); foreach (Subscription subscription in GetSubscriptions(modifiedFile)) { try { var parameterSubstitutions = new Dictionary <string, string> { { "<trigger-repo>", modifiedFile.RepoName }, { "<trigger-branch>", modifiedFile.BranchName }, { "<trigger-path>", modifiedFile.FullPath }, { "<trigger-commit>", modifiedFile.CommitId } }; ISubscriptionHandler subscriptionHandler = resolver.Resolve(subscription, parameterSubstitutions); subscriptionHandlers.Add(subscriptionHandler); } catch (Exception e) { Trace.TraceError(e.Message); } } return(subscriptionHandlers); }
private static void LoadBuiltIn(ISubscriptionHandler sh) { if (sh != null) { string path = Path.Combine(userSubscriberDirectory, Growl.CoreLibrary.PathUtility.GetSafeFolderName(sh.Name)); LoadInternal(sh, null, path); } }
public SubscriptionInfo(Type pSubType, Type pUnSubType, Type pNotifyType, ISubscriptionHandler pHandler) { SubType = pSubType; UnSubType = pUnSubType; NotifyType = pNotifyType; HandlerType = pHandler.GetType(); Handler = pHandler; }
public IThreadSubscriptionBuilder <TPayload> Invoke(ISubscriptionHandler <TPayload> handler) { Assert.ArgumentNotNull(handler, nameof(handler)); ValidateDoesNotHaveAction(); _actionReference = new SubscriptionHandlerActionReference <TPayload>(handler); return(this); }
/// <summary> /// Create a new DeviceHandlerBase /// </summary> /// <param name="deviceDescriptor">The descriptor describing the device</param> /// <param name="deviceEmptyHandler">An eventhandler to fire when the device can be removed</param> /// <param name="bindModeHandler">The event handler to fire when there is a Bind Mode event</param> protected DeviceHandlerBase(DeviceDescriptor deviceDescriptor, EventHandler <DeviceDescriptor> deviceEmptyHandler, EventHandler <BindModeUpdate> bindModeHandler) { _processUpdates = ProcessSubscriptionModeUpdates; BindModeUpdate = bindModeHandler; DeviceDescriptor = deviceDescriptor; _deviceEmptyHandler = deviceEmptyHandler; SubHandler = new SubscriptionHandler(deviceDescriptor, OnDeviceEmpty, CallbackHandler); }
public NodeRepublishSubscriptionHandler(ISubscriptionHandler <TPayload> inner, IPubSubBus messageBus, string nodeKey, string outputTopic, string errorTopic) { _inner = inner; _messageBus = messageBus; _nodeKey = nodeKey; _outputTopic = outputTopic; _errorTopic = errorTopic; }
public PiCalcMessageSubscriber( IBusClient busClient, IPiCalcService piCalcService, ISubscriptionHandler subscriptionHandler) : base(busClient) { this.busClient = busClient; this.piCalcService = piCalcService; this.subscriptionHandler = subscriptionHandler; }
private static void LoadInternal(ISubscriptionHandler ish, string installPath, string settingsPath) { string name = null; try { if (ish != null) { name = ish.Name; loadedHandlersList.Add(ish); List <Type> list = ish.Register(); foreach (Type type in list) { if (typeof(Subscription).IsAssignableFrom(type)) { if (!loadedTypes.ContainsKey(type)) { lock (loadedTypes) { if (!loadedTypes.ContainsKey(type)) { loadedTypes.Add(type, ish); } } } } } Utility.WriteDebugInfo(String.Format("Subscriber '{0}' was loaded successfully", name)); } } catch (Exception ex) { // suppress any per-plugin loading exceptions Utility.WriteDebugInfo(String.Format("Subscriber failed to load: '{0}' - {1} - {2}", name, ex.Message, ex.StackTrace)); } }
public T GetSubscriptionHandler <T>() { var objInfo = SubscriptionHandlers.FirstOrDefault(s => s.HandlerType.Equals(typeof(T))); ISubscriptionHandler objHandler = null; if (objInfo != null) { objHandler = objInfo.Handler; } return((T)objHandler); }
public SubscriptionHelper(DeviceDescriptor?deviceDescriptor = null) { if (deviceDescriptor == null) { deviceDescriptor = new DeviceDescriptor { DeviceHandle = "Test Device" }; } Device = (DeviceDescriptor)deviceDescriptor; SubHandler = new Hidwizards.IOWrapper.Libraries.SubscriptionHandlers.SubscriptionHandler(Device, EmptyHandler, CallbackHandler); ClearCallbacks(); DeviceEmptyResults = new List <DeviceDescriptor>(); }
public async Task Handle <TCommand>(TCommand command) { this.logger.LogInformation("Message Received: {@Message}", command); using var scope = this.serviceProvider.CreateScope(); ISubscriptionHandler <TCommand> handler = scope.ServiceProvider.GetRequiredService <ISubscriptionHandler <TCommand> >(); try { await handler.Handle(command).ConfigureAwait(false); } catch (Exception e) { this.logger.LogError(e, "Message handler failed"); } }
public IEnumerable <ISubscriptionHandler> GetHandlers(ModifiedFileModel modifiedFile) { List <ISubscriptionHandler> subscriptionHandlers = new List <ISubscriptionHandler>(); HandlerResolver resolver = new HandlerResolver(this); foreach (HandlerObject handlerObject in GetHandlerObjects(modifiedFile)) { ISubscriptionHandler subscriptionHandler = resolver.Resolve(handlerObject); if (subscriptionHandler != null) { subscriptionHandlers.Add(subscriptionHandler); } } return(subscriptionHandlers); }
private static void LoadPlugin(PluginInfo pi, ISubscriptionHandler ish) { try { // load if not already loaded if (ish == null) { PluginFinder pf = new PluginFinder(); ish = pf.Load <ISubscriptionHandler>(pi, ignoreList); } if (ish != null) { // for the 'path' value, we still want to use the userprofile directory no matter where the plugin was loaded from // the reason is that the 'path' is where plugin settings will be saved, so it needs to be user writable and user-specific string path = Path.Combine(userSubscriberDirectory, Growl.CoreLibrary.PathUtility.GetSafeFolderName(ish.Name)); // check to make sure this plugin was not loaded from another directory already if (!loadedPlugins.ContainsKey(path)) { loadedPlugins.Add(pi.FolderPath, pi); if (!loadedPlugins.ContainsKey(path)) { loadedPlugins.Add(path, pi); // link by the settings path as well so we can detect duplicate plugins in other folders } loadedPluginsList.Add(pi); LoadInternal(ish, pi.FolderPath, path); } else { // plugin was not valid Utility.WriteDebugInfo(String.Format("Subscriber not loaded: '{0}' - Duplicate plugin was already loaded from another folder", pi.FolderPath)); } } else { // plugin was not valid Utility.WriteDebugInfo(String.Format("Subscriber not loaded: '{0}' - Does not implement ISubscriptionHandler interface", pi.FolderPath)); } } catch (Exception ex) { // suppress any per-plugin loading exceptions Utility.WriteDebugInfo(String.Format("Subscriber failed to load: '{0}' - {1} - {2}", pi.FolderPath, ex.Message, ex.StackTrace)); } }
public ISubscriptionHandler Resolve(Subscription subscription) { JObject action = _subscriptionsModel.Actions.GetAction(subscription.Action); if (action == null) { throw new Exception($"Could not find a valid action with name '{subscription.Action}'."); } ISubscriptionHandler result = VsoBuildHandler.TryCreate(action, subscription); if (result == null) { throw new Exception($"Could not resolve a Handler for Subscription '{JsonConvert.SerializeObject(subscription)}'."); } return(result); }
// This function will get triggered/executed when a new message is written // on the DelayedMessage.QueueName Azure Queue. public static async Task ProcessQueueMessage( [QueueTrigger(DelayedMessage.QueueName)] DelayedMessage message, TextWriter log) { await log.WriteLineAsync("Starting " + message); await log.WriteLineAsync($"Deserializing {message.HandlerType}"); Type handlerType = Type.GetType(message.HandlerType); if (handlerType == null) { await log.WriteLineAsync($"Could not find type '{message.HandlerType}'. Skipping message '{message.HandlerData}'."); return; } ISubscriptionHandler handler = (ISubscriptionHandler)JsonConvert.DeserializeObject(message.HandlerData, handlerType); await handler.Execute(); }
public IEnumerable <ISubscriptionHandler> GetHandlers(ModifiedFileModel modifiedFile) { List <ISubscriptionHandler> subscriptionHandlers = new List <ISubscriptionHandler>(); HandlerResolver resolver = new HandlerResolver(this); foreach (Subscription subscription in GetSubscriptions(modifiedFile)) { try { ISubscriptionHandler subscriptionHandler = resolver.Resolve(subscription); subscriptionHandlers.Add(subscriptionHandler); } catch (Exception e) { Trace.TraceError(e.Message); } } return(subscriptionHandlers); }
public DeleteSubscriptionToNotifications(ISubscriptionHandler subscriptionHandler) { _subscriptionHandler = subscriptionHandler; }
public StopMessageSubscriber( ISubscriptionHandler subscriptionHandler, IBusClient busClient) : base(busClient) { this.subscriptionHandler = subscriptionHandler; }
public bool TryGetValue(string key, out ISubscriptionHandler value) => _handlers.TryGetValue(key, out value);
public SubscriptionHandlerActionReference(ISubscriptionHandler <TPayload> handler) { Assert.ArgumentNotNull(handler, nameof(handler)); _handler = handler; }
private static void LoadInternal(ISubscriptionHandler ish, string installPath, string settingsPath) { string name = null; try { if (ish != null) { name = ish.Name; loadedHandlersList.Add(ish); List<Type> list = ish.Register(); foreach (Type type in list) { if (typeof(Subscription).IsAssignableFrom(type)) { if (!loadedTypes.ContainsKey(type)) { lock (loadedTypes) { if (!loadedTypes.ContainsKey(type)) { loadedTypes.Add(type, ish); } } } } } Utility.WriteDebugInfo(String.Format("Subscriber '{0}' was loaded successfully", name)); } } catch (Exception ex) { // suppress any per-plugin loading exceptions Utility.WriteDebugInfo(String.Format("Subscriber failed to load: '{0}' - {1} - {2}", name, ex.Message, ex.StackTrace)); } }
private static void LoadPlugin(PluginInfo pi, ISubscriptionHandler ish) { try { // load if not already loaded if (ish == null) { PluginFinder pf = new PluginFinder(); ish = pf.Load<ISubscriptionHandler>(pi, ignoreList); } if (ish != null) { // for the 'path' value, we still want to use the userprofile directory no matter where the plugin was loaded from // the reason is that the 'path' is where plugin settings will be saved, so it needs to be user writable and user-specific string path = Path.Combine(userSubscriberDirectory, Growl.CoreLibrary.PathUtility.GetSafeFolderName(ish.Name)); // check to make sure this plugin was not loaded from another directory already if (!loadedPlugins.ContainsKey(path)) { loadedPlugins.Add(pi.FolderPath, pi); if (!loadedPlugins.ContainsKey(path)) loadedPlugins.Add(path, pi); // link by the settings path as well so we can detect duplicate plugins in other folders loadedPluginsList.Add(pi); LoadInternal(ish, pi.FolderPath, path); } else { // plugin was not valid Utility.WriteDebugInfo(String.Format("Subscriber not loaded: '{0}' - Duplicate plugin was already loaded from another folder", pi.FolderPath)); } } else { // plugin was not valid Utility.WriteDebugInfo(String.Format("Subscriber not loaded: '{0}' - Does not implement ISubscriptionHandler interface", pi.FolderPath)); } } catch (Exception ex) { // suppress any per-plugin loading exceptions Utility.WriteDebugInfo(String.Format("Subscriber failed to load: '{0}' - {1} - {2}", pi.FolderPath, ex.Message, ex.StackTrace)); } }
public Transport(int port, ISubscriptionHandler aggregationEngine) { _serverPort = port; _isShutdown = true; _aggregationEngine = aggregationEngine; }
public SubscriptionListItem(string text, Image image, ISubscriptionHandler ish) : base(text, image, ish) { }
public SubscribeToNotifications(ISubscriptionHandler subscriptionHandler) { _subscriptionHandler = subscriptionHandler; }