/// <summary> /// Register an plugin to be used in this configuration. /// </summary> /// <param name="key">The key used to identify the plugin.</param> /// <param name="priority">Used to determine plugins priority.</param> /// <param name="pluginAction">The plugin action to run.</param> public void AddPlugin(string key, int priority, Action <EventPluginContext> pluginAction) { RemovePlugin(key); var plugin = new PluginRegistration(key, priority, new Lazy <IEventPlugin>(() => new ActionPlugin(pluginAction))); if (!_plugins.TryAdd(key, plugin)) { Resolver.GetLog().Error(String.Format("Unable to add plugin: {0}", key)); } }
/// <summary> /// Register an plugin to be used in this configuration. /// </summary> /// <param name="key">The key used to identify the plugin.</param> /// <param name="priority">Used to determine plugins priority.</param> /// <param name="factory">A factory method to create the plugin.</param> public void AddPlugin(string key, int priority, Func <ExceptionlessConfiguration, IEventPlugin> factory) { RemovePlugin(key); var plugin = new PluginRegistration(key, priority, new Lazy <IEventPlugin>(() => factory(this))); if (!_plugins.TryAdd(key, plugin)) { Resolver.GetLog().Error(String.Format("Unable to add plugin: {0}", key)); } }
public void PluginTypeName_Accessor_EnforcesConstraints() { var registration = new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")); Assert.AreEqual(new TypeName("Plugin, Assembly"), registration.PluginTypeName); Assert.Throws <ArgumentNullException>(() => { registration.PluginTypeName = null; }); registration.PluginTypeName = new TypeName("DifferentPlugin, Assembly"); Assert.AreEqual(new TypeName("DifferentPlugin, Assembly"), registration.PluginTypeName); }
public void BaseDirectory_Accessor_EnforcesConstraints() { var registration = new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")); Assert.AreEqual(@"C:\", registration.BaseDirectory.ToString()); Assert.Throws <ArgumentNullException>(() => { registration.BaseDirectory = null; }); registration.BaseDirectory = new DirectoryInfo(@"D:\"); Assert.AreEqual(@"D:\", registration.BaseDirectory.ToString()); }
/// <summary> /// Register an plugin to be used in this configuration. /// </summary> /// <param name="key">The key used to identify the plugin.</param> /// <param name="pluginType">The plugin type to be added.</param> public void AddPlugin(string key, Type pluginType) { RemovePlugin(key); var plugin = new PluginRegistration(key, GetPriority(pluginType), new Lazy <IEventPlugin>(() => Resolver.Resolve(pluginType) as IEventPlugin)); if (!_plugins.TryAdd(key, plugin)) { Resolver.GetLog().Error(String.Format("Unable to add plugin: {0}", key)); } }
public void RecommendedInstallationPath_Accessor_EnforcesConstraints() { var registration = new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")); Assert.IsNull(registration.RecommendedInstallationPath); registration.RecommendedInstallationPath = "MyPlugin"; Assert.AreEqual("MyPlugin", registration.RecommendedInstallationPath); registration.RecommendedInstallationPath = null; Assert.IsNull(registration.RecommendedInstallationPath); }
public void FilePaths_Accessor_EnforcesConstraints() { var registration = new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")); Assert.IsEmpty(registration.FilePaths); Assert.Throws <ArgumentNullException>(() => { registration.FilePaths = null; }); var differentPaths = new[] { "file1.txt", "file2.dll" }; registration.FilePaths = differentPaths; Assert.AreSame(differentPaths, registration.FilePaths); }
public void EnableCondition_Accessor_EnforcesConstraints() { var registration = new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")); var condition = Condition.Parse("${minFramework:NET35}"); Assert.IsNull(registration.EnableCondition); registration.EnableCondition = condition; Assert.AreEqual(condition, registration.EnableCondition); registration.EnableCondition = null; Assert.IsNull(registration.EnableCondition); }
public void PluginDependencies_Accessor_EnforcesConstraints() { var registration = new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")); Assert.IsEmpty(registration.PluginDependencies); Assert.Throws <ArgumentNullException>(() => { registration.PluginDependencies = null; }); var differentDependencies = new[] { MockRepository.GenerateStub <IPluginDescriptor>() }; registration.PluginDependencies = differentDependencies; Assert.AreSame(differentDependencies, registration.PluginDependencies); }
public void AssemblyBindings_Accessor_EnforcesConstraints() { var registration = new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")); Assert.IsEmpty(registration.AssemblyBindings); Assert.Throws <ArgumentNullException>(() => { registration.AssemblyBindings = null; }); var differentReferences = new[] { new AssemblyBinding(new AssemblyName("Gallio")) }; registration.AssemblyBindings = differentReferences; Assert.AreSame(differentReferences, registration.AssemblyBindings); }
public void PluginHandlerFactory_Accessor_EnforcesConstraints() { var registration = new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")); Assert.IsInstanceOfType <SingletonHandlerFactory>(registration.PluginHandlerFactory); Assert.Throws <ArgumentNullException>(() => { registration.PluginHandlerFactory = null; }); var differentHandlerFactory = MockRepository.GenerateStub <IHandlerFactory>(); registration.PluginHandlerFactory = differentHandlerFactory; Assert.AreSame(differentHandlerFactory, registration.PluginHandlerFactory); }
public void TraitsProperties_Accessor_EnforcesConstraints() { var registration = new PluginRegistration("pluginId", new TypeName("Plugin, Assembly"), new DirectoryInfo(@"C:\")); Assert.IsEmpty(registration.TraitsProperties); Assert.Throws <ArgumentNullException>(() => { registration.TraitsProperties = null; }); var differentProperties = new PropertySet(); registration.TraitsProperties = differentProperties; Assert.AreSame(differentProperties, registration.TraitsProperties); }
public void Start(Uri uri, PluginRegistration pluginRegistration) { _pluginApi = new PluginApi( pluginRegistration.PluginInformation, pluginRegistration.CommandDescriptions); pluginRegistration.RegisterHttpApi(_pluginApi); var apiBootstrapper = new ApiBootstrapper(pluginRegistration.GetModules()); _nancyHost = new NancyHost(uri, apiBootstrapper); _nancyHost.Start(); }
private ArraySegment <byte> GetPluginRegistrationBytes() { var registration = new PluginRegistration { Event = _registerEvent, Uuid = _pluginUuid }; var outString = JsonConvert.SerializeObject(registration, _serialiserSettings); var outBytes = Encoding.UTF8.GetBytes(outString); return(outBytes); }
/// <summary> /// Register an plugin to be used in this configuration. /// </summary> /// <typeparam name="T">The plugin type to be added.</typeparam> /// <param name="plugin">The plugin instance to be added.</param> public void AddPlugin <T>(T plugin) where T : IEventPlugin { string key = typeof(T).FullName; RemovePlugin(key); #if !PORTABLE if (!_plugins.TryAdd(key, new PluginRegistration(key, GetPriority(typeof(T)), new Lazy <IEventPlugin>(() => plugin)))) { Resolver.GetLog().Error(String.Format("Unable to add plugin: {0}", key)); } #else _plugins[key] = new PluginRegistration(key, GetPriority(typeof(T)), new Lazy <IEventPlugin>(() => plugin)); #endif }
public void Launch(string pluginPath, AppDomain appDomain, Uri pluginApiUri, int clientPort, string tokenValue) { var token = Token.With(tokenValue); var assembly = appDomain.Load(AssemblyName.GetAssemblyName(pluginPath)); var pluginDirectory = Path.GetDirectoryName(pluginPath); appDomain.AssemblyResolve += (sender, args) => { var ad = sender as AppDomain; var path = Path.Combine(pluginDirectory, args.Name.Split(',')[0] + ".dll"); return ad.Load(path); }; var pluginBootstrapperType = assembly.GetTypes().Single(t => typeof (IPluginBootstrapper).IsAssignableFrom(t)); var pluginBootstrapper = (IPluginBootstrapper) Activator.CreateInstance(pluginBootstrapperType); var uri = new Uri($"http://127.0.0.1:{clientPort}"); var pluginRegistration = new PluginRegistration( uri, token, new CommandApi(pluginApiUri, token), new MessageApi(pluginApiUri, token), new HttpApi(), new Apis.PluginApi(pluginApiUri, token), new ConfigApi(pluginApiUri, token), new SettingApi(pluginApiUri, token)); pluginBootstrapper.Start(r => { r(pluginRegistration); if (pluginRegistration.PluginInformation == null) { throw new InvalidOperationException("You must call SetPluginInformation(...)"); } using (var a = AsyncHelper.Wait) { a.Run(pluginRegistration.CommandApi.RegisterAsync( pluginRegistration.CommandDescriptions, CancellationToken.None)); } }); _apiHost = new ApiHost(); _apiHost.Start(uri, pluginRegistration); }
public override Task <PluginRegistrationReply> Register(PluginRegistration request, ServerCallContext context) { try { if (_plugins.ContainsKey(request.PluginName)) { return(Task.FromResult(ConflictingName)); } if (_plugins.Values.Any(p => p == request.PluginPort)) { return(Task.FromResult(ConflictingPort)); } if (!_plugins.TryAdd(request.PluginName, request.PluginPort)) { return(Task.FromResult(UnknownError)); } return(Task.FromResult(Success)); } catch (Exception) { return(Task.FromResult(UnknownError)); } }
/// <summary> /// Register an plugin to be used in this configuration. /// </summary> /// <param name="key">The key used to identify the plugin.</param> /// <param name="priority">Used to determine plugins priority.</param> /// <param name="pluginAction">The plugin action to run.</param> public void AddPlugin(string key, int priority, Action <EventPluginContext> pluginAction) { _plugins[key] = new PluginRegistration(key, priority, new Lazy <IEventPlugin>(() => new ActionPlugin(pluginAction))); }
/// <summary> /// Register an plugin to be used in this configuration. /// </summary> /// <param name="key">The key used to identify the plugin.</param> /// <param name="priority">Used to determine plugins priority.</param> /// <param name="factory">A factory method to create the plugin.</param> public void AddPlugin(string key, int priority, Func <ExceptionlessConfiguration, IEventPlugin> factory) { _plugins[key] = new PluginRegistration(key, priority, new Lazy <IEventPlugin>(() => factory(this))); }
/// <summary> /// Register an plugin to be used in this configuration. /// </summary> /// <param name="key">The key used to identify the plugin.</param> /// <param name="pluginType">The plugin type to be added.</param> public void AddPlugin(string key, Type pluginType) { _plugins[key] = new PluginRegistration(key, GetPriority(pluginType), new Lazy <IEventPlugin>(() => Resolver.Resolve(pluginType) as IEventPlugin)); }
/// <summary> /// Register an plugin to be used in this configuration. /// </summary> /// <typeparam name="T">The plugin type to be added.</typeparam> /// <param name="plugin">The plugin instance to be added.</param> public void AddPlugin <T>(T plugin) where T : IEventPlugin { string key = typeof(T).FullName; _plugins[key] = new PluginRegistration(key, GetPriority(typeof(T)), new Lazy <IEventPlugin>(() => plugin)); }
public override async Task <PluginRegistrationReply> Register(PluginRegistration request, ServerCallContext context) { return(new PluginRegistrationReply()); }