public CustomLogFileFormat(PluginId pluginId, string name, string format, Encoding encoding)
{
_pluginId = pluginId;
_name = name;
_format = format;
_encoding = encoding;
}
public async Task <PluginInformation> InstallPluginAsync(Uri uri, CancellationToken cancellationToken)
{
var filename = uri.GetFilename();
if (!uri.ToString().ToLowerInvariant().EndsWith(".zip"))
{
throw new ArgumentException($"Only understands ZIP files: {uri} ({filename})");
}
var pluginId = PluginId.With(Path.GetFileNameWithoutExtension(filename).ToLowerInvariant());
if (_plugins.ContainsKey(pluginId))
{
await _pluginInstaller.UninstallPluginAsync(pluginId, cancellationToken).ConfigureAwait(false);
}
using (var tempFile = await _restClient.DownloadAsync(uri, cancellationToken).ConfigureAwait(false))
{
var pluginPath = await _pluginInstaller.InstallPluginAsync(
pluginId,
tempFile,
PluginPackageType.Zip,
cancellationToken)
.ConfigureAwait(false);
return(await LoadPluginAsync(
pluginPath,
cancellationToken)
.ConfigureAwait(false));
}
}
public async Task <PluginPath> InstallPluginAsync(
PluginId pluginId,
TempFile tempFile,
PluginPackageType packageType,
CancellationToken cancellationToken)
{
var installDirectory = GetInstallDirectory(pluginId);
_logger.Verbose($"Installing plugin '{pluginId}' into '{installDirectory}'");
switch (packageType)
{
case PluginPackageType.Zip:
{
await tempFile.ExtractZipAsync(installDirectory, cancellationToken).ConfigureAwait(false);
var pluginDll = Path.Combine(installDirectory, $"{pluginId}.dll");
_logger.Verbose($"Guessing that plugin location is '{pluginDll}'");
return(new PluginPath(pluginDll));
}
default:
throw new ArgumentOutOfRangeException(nameof(packageType), packageType, null);
}
}
internal void Load()
{
(Assemblies as List <string>).Clear();
foreach (FileInfo f in new DirectoryInfo(Path).GetFiles("*.dll", SearchOption.TopDirectoryOnly))
{
if (isDotNetAssembly(f.FullName))
{
(Assemblies as List <string>).Add(f.FullName);
}
}
if (Domain != null)
{
FireHandleUnloadAppDomain();
Domain = null;
}
Domain = ProxyDomain.CreateDomain(PluginId.ToString(), Path);
foreach (string p in Assemblies)
{
Domain.LoadAssembly(p);
}
AppDomain.CurrentDomain.AssemblyResolve += CurrentDomainOnAssemblyResolve;
var m = Domain.Create <IPlugin>();
_plugin = m;
}
/// <summary>
/// Load all the programs for the given plugin from the given directory.
/// </summary>
public static bool LoadPluginPrograms(PluginId pluginId, [MarshalAs(UnmanagedType.LPWStr)] string path)
{
Id.Check(pluginId);
Contract.Requires(!string.IsNullOrEmpty(path));
Contract.Requires(Directory.Exists(path));
return(NowSoundGraph_LoadPluginPrograms(pluginId, path));
}
/// <summary>
/// Get the name of the Nth plugin. Note that IDs are 1-based.
/// </summary>
public static void PluginName(PluginId pluginId, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder buffer)
{
Id.Check(pluginId);
Contract.Requires(buffer != null);
Contract.Requires(buffer.Capacity > 0);
NowSoundGraph_PluginName(pluginId, buffer, buffer.Capacity);
}
public async Task UnloadPlugin([FromBody] TenantMessage tenantMessage, CancellationToken cancellationToken)
{
var pId = RegexUnloadPlugin.Match(tenantMessage.Text).Groups["pluginId"].Value;
var pluginId = PluginId.With(pId);
await _pluginApi.UnloadPluginAsync(pluginId, cancellationToken).ConfigureAwait(false);
await _messageApi.ReplyToAsync(tenantMessage, $"Unloaded plugin {pluginId}", cancellationToken).ConfigureAwait(false);
}
/// <summary>
/// Get the number of programs for the given plugin.
/// </summary>
public static int PluginProgramCount(PluginId pluginId)
{
Id.Check(pluginId);
int result = NowSoundGraph_PluginProgramCount(pluginId);
Contract.Assert(result >= 0);
return(result);
}
public PluginProxy(
PluginId id,
AppDomain appDomain,
IPlugin plugin)
{
Id = id;
Plugin = plugin;
_appDomain = appDomain;
}
public PluginProxy(
PluginId id,
AppDomain appDomain,
IPlugin plugin)
{
Id = id;
Plugin = plugin;
_appDomain = appDomain;
}
public Task RegisterAsync(PluginId pluginId, IEnumerable <CommandDescription> commandDescriptions)
{
var commandDescriptionList = commandDescriptions.ToList();
_pluginCommandDescriptions[pluginId] = commandDescriptionList;
_logger.Verbose($"Registerd commands for '{pluginId}': {string.Join(", ", commandDescriptionList.Select(d => d.ToString()))}");
return(Task.FromResult(0));
}
public static Delegate GetFunction <TDelegate>(PluginId id, string name)
{
var ptr = get_plugin_function(id.Ptr, name);
if (ptr == IntPtr.Zero)
{
throw new FunctionNotFoundException(name);
}
return(Marshal.GetDelegateForFunctionPointer(ptr, typeof(TDelegate)));
}
public Task UninstallPluginAsync(PluginId pluginId, CancellationToken cancellationToken)
{
var installDirectory = GetInstallDirectory(pluginId);
if (_fileSystemClient.DirectoryExists(installDirectory))
{
_logger.Warning($"Plugin '{pluginId}' is now installed, but request to be uninstalled");
return Task.FromResult(0);
}
return Task.Run(() => _fileSystemClient.DeleteDirectory(installDirectory), cancellationToken);
}
public Task UninstallPluginAsync(PluginId pluginId, CancellationToken cancellationToken)
{
var installDirectory = GetInstallDirectory(pluginId);
if (_fileSystemClient.DirectoryExists(installDirectory))
{
_logger.Warning($"Plugin '{pluginId}' is now installed, but request to be uninstalled");
return(Task.FromResult(0));
}
return(Task.Run(() => _fileSystemClient.DeleteDirectory(installDirectory), cancellationToken));
}
public static PluginInstanceIndex AddPluginInstance(TrackId trackId, PluginId pluginId, ProgramId programId, int dryWet_0_100)
{
Id.Check(trackId);
Id.Check(pluginId);
Id.Check(programId);
Contract.Requires(dryWet_0_100 >= 0);
Contract.Requires(dryWet_0_100 <= 100);
PluginInstanceIndex result = NowSoundTrack_AddPluginInstance(trackId, pluginId, programId, dryWet_0_100);
Id.Check(result);
return(result);
}
public override int GetHashCode()
{
return(Id.GetHashCode() ^
AssemblyId.GetHashCode() ^
PluginId.GetHashCode() ^
StepId.GetHashCode() ^
Attributes.GetHashCode() ^
Name.GetHashCode() ^
RelatedAttribute.GetHashCode() ^
EntityAlias.GetHashCode() ^
ImageType.GetHashCode() ^
MessagePropertyName.GetHashCode());
}
public Task UnloadPluginAsync(PluginId pluginId)
{
if (!_plugins.ContainsKey(pluginId))
{
return(Task.FromResult(0));
}
IPluginProxy pluginProxy;
_plugins.TryRemove(pluginId, out pluginProxy);
pluginProxy.Dispose();
return(Task.FromResult(0));
}
public static PluginInformation With(
PluginId id,
PluginTitle title,
PluginVersion version,
PluginDescription description,
Uri uri)
{
return new PluginInformation(
id,
title,
version,
description,
uri);
}
public void Setup()
{
_serviceContainer = new ServiceContainer();
_registry = new Mock <ILogFileFormatRegistry>();
_serviceContainer.RegisterInstance(_registry.Object);
_settings = new Mock <IApplicationSettings>();
_customFormatsSettings = new CustomFormatsSettings();
_settings.SetupGet(x => x.CustomFormats).Returns(_customFormatsSettings);
_pluginId = new PluginId("221dwdwaddwa");
_plugin = new Mock <ICustomLogFileFormatCreatorPlugin>();
_encodings = new[] { new EncodingViewModel(Encoding.Default) };
}
public void Start(Action <Action <IPluginRegistration> > pluginRegistra)
{
pluginRegistra(r =>
{
var assembly = typeof(HelpPluginBootstrapper).Assembly;
r.SetPluginInformation(PluginInformation.With(
PluginId.From(assembly),
PluginTitle.With("Help"),
PluginVersion.From(assembly),
PluginDescription.With("Provides help for the Borg"),
r.Uri));
r.RegisterHttpApi(new HelpApi(r.HttpApi, r.MessageApi, r.PluginApi));
r.RegisterHttpApiCommands();
});
}
public void Start(Action <Action <IPluginRegistration> > pluginRegistra)
{
pluginRegistra(r =>
{
var assembly = typeof(JokesPluginBootstrapper).Assembly;
r.SetPluginInformation(PluginInformation.With(
PluginId.From(assembly),
PluginTitle.With("Jokes"),
PluginVersion.From(assembly),
PluginDescription.With("Provides jokes"),
r.Uri));
r.RegisterHttpApi(new JokesApi(r.ConfigApi, r.HttpApi, r.MessageApi));
r.RegisterHttpApiCommands();
});
}
public CustomFormatViewModel(IServiceContainer serviceContainer,
IApplicationSettings settings,
ICustomLogFileFormatCreatorPlugin plugin,
IEnumerable <EncodingViewModel> encodings,
CustomLogFileFormat customFormat)
{
_serviceContainer = serviceContainer;
_settings = settings;
_logFileFormatRegistry = serviceContainer.Retrieve <ILogFileFormatRegistry>();
_pluginId = customFormat.PluginId;
_plugin = plugin;
_encodings = encodings;
_customFormat = customFormat;
_name = customFormat.Name;
_encoding = Encodings.FirstOrDefault(x => Equals(x.Encoding, customFormat.Encoding));
_format = customFormat.Format;
}
public void Start(Action <Action <IPluginRegistration> > pluginRegistra)
{
pluginRegistra(r =>
{
var assembly = typeof(GitHubPluginBootstrapper).Assembly;
var gitHubClientFactory = new GitHubClientFactory(r.ConfigApi);
var gitHubService = new GitHubService(gitHubClientFactory);
r.SetPluginInformation(PluginInformation.With(
PluginId.From(assembly),
PluginTitle.With("GitHub"),
PluginVersion.From(assembly),
PluginDescription.With("Provides GitHub support for the Borg"),
r.Uri));
r.RegisterHttpApi(new GitHubApi(r.MessageApi, gitHubService));
r.RegisterHttpApiCommands();
});
}
public PluginInformation(
PluginId id,
PluginTitle title,
PluginVersion version,
PluginDescription description,
Uri uri)
{
if (id == null) throw new ArgumentNullException(nameof(id));
if (title == null) throw new ArgumentNullException(nameof(title));
if (version == null) throw new ArgumentNullException(nameof(version));
if (description == null) throw new ArgumentNullException(nameof(description));
if (uri == null) throw new ArgumentNullException(nameof(uri));
Id = id;
Title = title;
Version = version;
Description = description;
Uri = uri;
}
public CustomFormatPluginViewModel(IServiceContainer serviceContainer,
IApplicationSettings settings,
PluginId pluginId,
ICustomLogFileFormatCreatorPlugin plugin,
IEnumerable <EncodingViewModel> encodings)
{
_serviceContainer = serviceContainer;
_settings = settings;
_pluginId = pluginId;
_plugin = plugin;
_encodings = encodings;
_name = plugin.FormatName;
_addCommand = new DelegateCommand2(Add);
_formats = new ObservableCollection <CustomFormatViewModel>();
foreach (var customFormat in _settings.CustomFormats)
{
Add(customFormat);
}
}
public void Restore(XmlReader reader)
{
var count = reader.AttributeCount;
for (var i = 0; i < count; ++i)
{
reader.MoveToAttribute(i);
switch (reader.Name)
{
case "plugin":
_pluginId = new PluginId(reader.ReadContentAsString());
break;
case "name":
_name = reader.ReadContentAsString();
break;
case "format":
_format = reader.ReadContentAsString();
break;
case "encoding":
var encodingName = reader.ReadContentAsString();
if (!string.IsNullOrEmpty(encodingName))
{
try
{
_encoding = Encoding.GetEncoding(encodingName);
}
catch (Exception e)
{
Log.WarnFormat("Caught exception while trying to get encoding '{0}':\r\n{1}",
encodingName,
e);
}
}
break;
}
}
}
private void CreatePlugin <T>(string pluginFolder, PluginId actualId, Version actualVersion, PluginId fakeId, Version fakeVersion) where T : IPlugin
{
using (var stream = new MemoryStream())
{
using (var packer = PluginPacker.Create(stream, true))
{
var idx = actualId.Value.LastIndexOf(".");
var actualNamespace = actualId.Value.Substring(0, idx);
var actualName = actualId.Value.Substring(idx + 1);
var builder = new PluginBuilder(actualNamespace, actualName, "none of your business", "get of my lawn", version: actualVersion);
builder.ImplementInterface <T>("Plugin.FileFormatPlugin");
builder.Save();
packer.AddPluginAssembly(builder.FileName);
}
stream.Position = 0;
var path = Path.Combine(pluginFolder, $"{fakeId.Value}.{fakeVersion}.tvp");
_filesystem.CreateDirectory(pluginFolder);
_filesystem.WriteAllBytes(path, stream.ToArray());
}
}
public async Task<PluginPath> InstallPluginAsync(
PluginId pluginId,
TempFile tempFile,
PluginPackageType packageType,
CancellationToken cancellationToken)
{
var installDirectory = GetInstallDirectory(pluginId);
_logger.Verbose($"Installing plugin '{pluginId}' into '{installDirectory}'");
switch (packageType)
{
case PluginPackageType.Zip:
{
await tempFile.ExtractZipAsync(installDirectory, cancellationToken).ConfigureAwait(false);
var pluginDll = Path.Combine(installDirectory, $"{pluginId}.dll");
_logger.Verbose($"Guessing that plugin location is '{pluginDll}'");
return new PluginPath(pluginDll);
}
default:
throw new ArgumentOutOfRangeException(nameof(packageType), packageType, null);
}
}
public void TestIgnoreIdenticalPlugin()
{
var id = new PluginId("Kittyfisto.Simon");
var version = new Version(4, 3, 2);
CreatePlugin <ILogEntryParserPlugin>(Constants.PluginPath, id, version);
CreatePlugin <ILogEntryParserPlugin>(Constants.DownloadedPluginsPath, id, version);
using (var loader = new PluginArchiveLoader(_filesystem, new []
{
Constants.PluginPath,
Constants.DownloadedPluginsPath
}))
{
var pluginsWithDescription = loader.LoadAllOfTypeWithDescription <ILogEntryParserPlugin>();
pluginsWithDescription.Should().HaveCount(1, "because only one instance of that plugin should've been loaded");
var plugin1 =
pluginsWithDescription.FirstOrDefault(x => x.Description.Id == new PluginId("Kittyfisto.Simon"));
plugin1.Should().NotBeNull();
plugin1.Description.Version.Should().Be(new Version(4, 3, 2));
}
}
private static string ConfigKey(PluginId pluginId, string key)
{
return $"{pluginId.Value}:{key}";
}
public Task RegisterAsync(PluginId pluginId, IEnumerable<CommandDescription> commandDescriptions)
{
var commandDescriptionList = commandDescriptions.ToList();
_pluginCommandDescriptions[pluginId] = commandDescriptionList;
_logger.Verbose($"Registerd commands for '{pluginId}': {string.Join(", ", commandDescriptionList.Select(d => d.ToString()))}");
return Task.FromResult(0);
}
private string GetInstallDirectory(PluginId pluginId)
{
var pluginInstallPath = _configuration.PluginInstallPath;
return Path.Combine(pluginInstallPath, pluginId.Value);
}
public Task UnloadPluginAsync(PluginId pluginId)
{
if (!_plugins.ContainsKey(pluginId))
{
return Task.FromResult(0);
}
IPluginProxy pluginProxy;
_plugins.TryRemove(pluginId, out pluginProxy);
pluginProxy.Dispose();
return Task.FromResult(0);
}
public Task UnloadPluginAsync(PluginId pluginId, CancellationToken cancellationToken)
{
return PostAsync($"api/plugins/{pluginId.Value}/unload", null as object, cancellationToken);
}
public PluginIdentity(
PluginId id)
{
Id = id;
}
private string GetInstallDirectory(PluginId pluginId)
{
var pluginInstallPath = _configuration.PluginInstallPath;
return(Path.Combine(pluginInstallPath, pluginId.Value));
}
private void CreatePlugin <T>(string pluginFolder, PluginId actualId, Version actualVersion) where T : IPlugin
{
CreatePlugin <T>(pluginFolder, actualId, actualVersion, actualId, actualVersion);
}
public static SettingGroupKey ToSettingGroupKey(this PluginId pluginId)
{
return SettingGroupKey.With($"plugin.{pluginId.Value}");
}
private void CreatePlugin <T>(PluginId actualId, Version actualVersion, PluginId fakeId, Version fakeVersion) where T : IPlugin
{
CreatePlugin <T>(Constants.PluginPath, actualId, actualVersion, fakeId, fakeVersion);
}
public void TestToString()
{
var id = new PluginId("MyCompany.Namespace.Log");
id.ToString().Should().Be("MyCompany.Namespace.Log");
}
public override int GetHashCode()
{
return(EditedPluginId.GetHashCode() ^ PluginId.GetHashCode());
}