public async Task <CalculationResponseModel> Calculate(CalculationRequestModel requestModel) { var _plugin = await loader.Load(); // The plugin is eagerly loaded (in-scope) return(new CalculationResponseModel { Result = _plugin.Calculate(requestModel.A, requestModel.B) }); }
public async Task <CalculationResponseModel> Calculate(CalculationRequestModel requestModel) { // Load the plugin on-demand var plugin = await _loader.Load(); return(new CalculationResponseModel { Result = plugin.Calculate(requestModel.A, requestModel.B) }); }
public async Task <IEnumerable <Product> > Get([FromQuery] string searchTerm) { var repository = await loader.Load(); if (String.IsNullOrEmpty(searchTerm)) { return(await repository.All()); } return(await repository.Search(searchTerm)); }
/// <summary> /// Load the plugin on-demand via the Load() or LoadAll() method /// </summary> /// <param name="input"></param> /// <returns></returns> public async Task <string> Get([FromQuery] string input) { var plugin = await _pluginLoader.Load(); var response = plugin.SayHello(input); await _pluginLoader.Unload(); return(response); }
public IPluginContainer LoadPlugin(string file) { if (File.Exists(file)) { throw new FileNotFoundException("Plugin file not found", file); } var pluginContainer = Loader.Load(file); _loadedPlugins.Add(pluginContainer.GetName(), pluginContainer); return(pluginContainer); }
/// <summary> /// Initializes this instance. /// </summary> public void Initialize() { _plugins.Clear(); var items = _loader.Load(); items.ForEach( plugin => { plugin.Initialize(); _plugins.Add(plugin.Key, plugin); }); }
/// <summary> /// Process an already loaded <c>YamlDocument</c> and returns the loaded suite model. /// </summary> /// <param name="yaml">The yaml document to process.</param> /// <returns>Returns a loaded model if succeeds. On error it throws an exception, never /// returns <c>null</c>.</returns> protected Suite LoadYaml(YamlDocument yaml) { Contract.Requires(yaml != null); Contract.Requires(yaml.RootNode != null); Contract.Ensures(Contract.Result <Suite>() != null); log.Debug("Processing YAML document..."); foreach (var pluginUri in LoadPlugins(yaml.RootNode)) { pluginLoader.Load(pluginUri); } var goals = LoadGoals(yaml.RootNode); var defaultGoal = LoadDefaultGoal(goals, yaml.RootNode) ?? Suite.DebugGoal; var suite = suiteFactory.CreateSuite(new HashSet <Goal>(goals.Values), defaultGoal); parser.SetActiveGoal(suite.ActiveGoal); suite.Name = parser.GetScalarValue(yaml.RootNode, "suite", "Error reading the name of the suite"); suite.Version = ParseVersion(parser.GetOptionalScalarValue(yaml.RootNode, "version", null)); suite.Copyright = parser.GetOptionalScalarValue(yaml.RootNode, "copyright", null); LoadParameters(suite, suite, yaml.RootNode); foreach (KeyValuePair <string, YamlNode> item in parser.EnumerateNamedNodesOf(yaml.RootNode, "modules")) { var module = suite.GetModule(item.Key); if (item.Value != null) { LoadModule(module, item.Value); } } foreach (KeyValuePair <string, YamlNode> item in parser.EnumerateNamedNodesOf(yaml.RootNode, "products")) { var product = suite.GetProduct(item.Key); if (item.Value != null) { LoadProduct(suite, product, item.Value); } } LoadSourceSetIgnoreLists(suite.SourceSetIgnoreLists, yaml.RootNode); validator.Validate(suite); log.Debug("Finished processing YAML document."); return(suite); }
public MainWindow() { try { eventBus = new EventBus(); Container.Current.Register <IEventBus>(eventBus); //Fixes an issue with current directory being system32 for the plugin loader and not the application path as desired eventBus.Publish(new LogEntryPublished("Heibroch.Launch - Initializing", "Setting base directory...", EventLogEntryType.Information)); Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory); eventBus.Publish(new LogEntryPublished("Heibroch.Launch - Initializing", "Initializing components...", EventLogEntryType.Information)); InitializeComponent(); var logService = new LogService(eventBus); Container.Current.Register <ILogService>(logService); eventBus.Publish(new LogEntryPublished("Heibroch.Launch - Initializing", "Initializing plugin loader...", EventLogEntryType.Information)); pluginLoader = new PluginLoader(eventBus, Container.Current); Container.Current.Register <IPluginLoader>(pluginLoader); eventBus.Publish(new LogEntryPublished("Heibroch.Launch - Initializing", "Initializing shortcut collection...", EventLogEntryType.Information)); var shortcutCollection = new ShortcutCollection(pluginLoader, eventBus); Container.Current.Register <IShortcutCollection <string, ILaunchShortcut> >(shortcutCollection); eventBus.Publish(new LogEntryPublished("Heibroch.Launch - Initializing", "Initializing shortcut executor...", EventLogEntryType.Information)); var shortcutExecutor = new ShortcutExecutor(shortcutCollection); Container.Current.Register <IShortcutExecutor>(shortcutExecutor); eventBus.Publish(new LogEntryPublished("Heibroch.Launch - Initializing", "Initializing setting collection...", EventLogEntryType.Information)); var settingCollection = new SettingCollection(eventBus); Container.Current.Register <ISettingCollection>(settingCollection); eventBus.Publish(new LogEntryPublished("Heibroch.Launch - Initializing", "Initializing plugins...", EventLogEntryType.Information)); pluginLoader.Load(); eventBus.Publish(new ProgramLoadedEvent()); eventBus.Publish(new LogEntryPublished("Heibroch.Launch - Initializing", "Initializing main view model...", EventLogEntryType.Information)); DataContext = new MainViewModel(eventBus, shortcutCollection, shortcutExecutor, settingCollection, pluginLoader); eventBus.Publish(new LogEntryPublished("Heibroch.Launch - Initializing", "Initializing hooks...", EventLogEntryType.Information)); hookId = SetHook(proc); Closing += OnMainWindowClosing; eventBus.Publish(new LogEntryPublished("Heibroch.Launch - Initializing", "Initialization complete", EventLogEntryType.Information)); } catch (Exception ex) { eventBus.Publish(new LogEntryPublished("Heibroch.Launch", ex.StackTrace, EventLogEntryType.Error)); throw ex; } }
private void LoadPlugins(string dllFileName) { // TODO: can be done via UI at runtime try { // TODO: add a plugin manager or smth Assembly assembly = GetAssembly(dllFileName); pluginLoader_.Load(assembly); } catch (Exception e) { // TODO: log } }
public bool LoadPlugin <TPlugin>(FileInfo fileInfo, IPluginLoader <TPlugin> pluginLoader = null) where TPlugin : class, IPlugin { pluginLoader ??= new PluginLoader <TPlugin>(this); TPlugin plugin = pluginLoader.Load(fileInfo); if (plugin == null) { return(false); } ListPlugins.Add(plugin); PluginLoadedEventArgs loadedEventArgs = new PluginLoadedEventArgs(plugin); EventsManager.CallEvent(loadedEventArgs); return(true); }
public void InitializePlugins() { lock (PluginInitializationLocker) { _log.Trace(Resources.Resources.PluginInitializer_InitializePlugins_Plugins_initialization_started); var pluginInstances = _pluginLoader.Load(); var initialized = 0; foreach (var plugin in pluginInstances) { _pluginProvider.Initialize(plugin); initialized++; } _log.Debug( Resources.Resources.PluginInitializer_InitializePlugins_Plugins_Initialization_finished.FormatWith(initialized)); } }
public void ShouldLoadItPlugin() { var result = _pluginLoader.Load().ToArray(); result.Should().NotBeNullOrEmpty(); }
public async Task <CalculationResponseModel> Calculate(CalculationRequestModel requestModel) { // Load the plugin on-demand base.SetPlugin(await _loader.Load()); return(base.Calculate(requestModel)); }
public async Task Delete(int productId) { var repository = await deleterLoader.Load(); await repository.Delete(productId); }
public async Task <Product> Create(Product product) { var repository = await writerLoader.Load(); return(await repository.Create(product)); }
/// <summary> /// Load the plugin on-demand via the Load() or LoadAll() method /// </summary> /// <param name="input"></param> /// <returns></returns> public async Task <string> Get([FromQuery] string input) { var plugin = await _pluginLoader.Load(); return(plugin.SayHello(input)); }