/// <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());
}
