public void FetchPlugins()
{
LoadedPlugins = FetchPluginsImpl().ToList();
for (var i = 0; i < LoadedPlugins.Count; i++)
{
LoadedPlugins[i].Enabled = Globals.SettingsHelper.FetchPlugin(LoadedPlugins[i].PluginHostGuid).Enabled;
}
LoadedPlugins.ForEach(lp =>
{
var pluginMd = Globals.SettingsHelper.FetchPlugin(lp.PluginHostGuid);
if (lp.PluginHost.Plugins != null && pluginMd.Enabled)
{
lp.PluginHost.Plugins.ForEach(lpp =>
{
if (lpp.PluginPackets != null)
{
lpp.PluginPackets.ForEach(lppp =>
{
Globals.PacketProcessor.PacketTable.Add(lppp.PacketId, lppp.GetType());
});
}
lpp.Initialize();
});
}
});
}
private IEnumerable <RemoteClientPlugin> FetchRemotePluginsImpl()
{
foreach (var file in Directory.GetFiles(Application.StartupPath + "\\plugins\\client"))
{
if (!file.GetFileName().ToLower().Contains("plugin"))
{
continue;
}
if (!file.GetFileName().EndsWith(".dll"))
{
continue;
}
var fileBuff = File.ReadAllBytes(file);
var asm = Assembly.LoadFile(file);
var attribute = (GuidAttribute)asm.GetCustomAttributes(typeof(GuidAttribute), true)[0];
var remotePlugin = new RemoteClientPlugin(file, fileBuff, HashHelper.CalculateSha256(fileBuff))
{
PluginGuid = new Guid(attribute.Value)
};
remotePlugin.AssociatedServerPluginHost =
LoadedPlugins.First(p => p.PluginHost.AssociatedClientPlugin.Equals(new Guid(attribute.Value)));
yield return(remotePlugin);
}
}
private void CloseTab(Plugin plugin)
{
if (!CanClose(plugin))
{
return;
}
bool changeSelection = (plugin == SelectedPlugin);
int selectedIndex = LoadedPlugins.IndexOf(plugin);
_pluginController.RemovePlugin(plugin);
if (changeSelection)
{
int count = LoadedPlugins.Count;
if (count == 0)
{
SelectedPlugin = null;
}
else
{
if (selectedIndex >= count)
{
selectedIndex = count - 1;
}
SelectedPlugin = LoadedPlugins[selectedIndex];
}
}
}
public async Task AddPlugin(string settingFile, List <ZipArchiveEntry> files)
{
var plugin = JsonConvert.DeserializeObject <Plugin>(settingFile);
plugin.Valid = true;
if (LoadedPlugins.Any())
{
plugin.Priority = LoadedPlugins.Max(x => x.Priority) + 1;
}
else
{
plugin.Priority = 1;
}
var loadeds = new List <Plugin>(LoadedPlugins);
Directory.CreateDirectory($"plugins/{plugin.PluginPath}");
plugin.IsEnabled = false;
foreach (var file in files)
{
file.ExtractToFile(Path.Combine($"plugins/{plugin.PluginPath}", file.FullName), true);
}
PreCompilePlugin(plugin);
loadeds.Add(plugin);
LoadedPlugins = loadeds;
await File.WriteAllTextAsync(PluginSettingPath, JsonConvert.SerializeObject(LoadedPlugins));
}
public async Task PatchPluginPriority(string pluginPath, int priority)
{
var plugin = LoadedPlugins.FirstOrDefault(x => x.PluginPath == pluginPath);
plugin.Priority = priority;
await SavePluginInfo();
}
public async Task PatchPluginActivatedBoards(string pluginPath, string[] activatedBoards)
{
var plugin = LoadedPlugins.FirstOrDefault(x => x.PluginPath == pluginPath);
plugin.ActivatedBoards = activatedBoards;
await SavePluginInfo();
}
protected void OnRemoveActionActivated(object sender, EventArgs e)
{
Gtk.ResponseType responseType = Gtk.ResponseType.None;
LoadedPlugins loadedPlugins = new LoadedPlugins(plugins);
try {
responseType = (Gtk.ResponseType)loadedPlugins.Run();
if (responseType == Gtk.ResponseType.Ok)
{
Gtk.TreeModel model;
Gtk.TreeIter iter;
Gtk.TreeSelection selection = loadedPlugins.treeView.Selection;
selection.GetSelected(out model, out iter);
string pluginToDelete = (model.GetValue(iter, 0).ToString());
removePlugin(pluginToDelete);
//plugins.RemovePlugin(pluginToDelete);
//DockItem item = DockFrame.GetItem(pluginToDelete);
//item.Visible = false;
//dockFrame.RemoveItem(item);
SaveLayout();
}
}
finally {
loadedPlugins.Hide();
loadedPlugins.Dispose();
}
}
public async Task PatchPluginEnable(string pluginPath, bool enable)
{
var plugin = LoadedPlugins.FirstOrDefault(x => x.PluginPath == pluginPath);
plugin.IsEnabled = enable;
await SavePluginInfo();
}
// Board settings will allow only key-value pair and value is not nested item or array.
// ex.
// Settings: {
// "Name" : "text", // allow
// "Users" : [ "Kain", "KOJIMA" ] // allow
// "UserDetail" : [ { "name" : "kain", auth: false } ] // disallow
// }
public async Task <string> GetBoardPluginSetting(string boardKey, string pluginPath)
{
var path = GetPluginBoardSettingPath(boardKey, pluginPath);
if (!File.Exists(path))
{
var plugin = LoadedPlugins.FirstOrDefault(x => x.PluginPath == pluginPath);
if (plugin == null)
{
throw new InvalidOperationException("Not found plugin");
}
else
{
if (plugin.HasBoardSetting)
{
return(JsonConvert.SerializeObject(plugin.DefaultBoardSetting));
}
else
{
throw new InvalidOperationException("This plugin cannot has settings.");
}
}
}
return(await File.ReadAllTextAsync(path));
}
protected void OnRemoveActionActivated(object sender, EventArgs e)
{
Gtk.ResponseType responseType = Gtk.ResponseType.None;
LoadedPlugins loadedPlugins = new LoadedPlugins(plugins);
try {
responseType = (Gtk.ResponseType)loadedPlugins.Run();
if (responseType == Gtk.ResponseType.Ok)
{
Gtk.TreeModel treeModel;
Gtk.TreeIter iter;
Gtk.TreePath[] selectedRows = null;
selectedRows = loadedPlugins.treeView.Selection.GetSelectedRows();
for (int i = 0; i < selectedRows.Length; i++)
{
loadedPlugins.lsLoadedPlugins.GetIter(out iter, selectedRows[i]);
string pluginPath = (string)loadedPlugins.lsLoadedPlugins.GetValue(iter, 0);
PluginInfo pluginInfo = plugins.Plugins.Find(x => x.codeBase == pluginPath);
List <IService> services = plugins.GetServices(pluginInfo);
foreach (IService service in services)
{
plugins.RemovePlugin(pluginInfo.codeBase);
(service as IPlugin).UnInit(null);
}
}
}
}
finally {
loadedPlugins.Hide();
}
}
} = 3000; // Milliseconds
#endregion
#region PUBLIC
public static void AddNewPlugin(IPlugin newPlugin)
{
if (newPlugin != null &&
LoadedPlugins.FindAll(elem => elem.Config.Name == newPlugin.Config.Name).Count <= 0)
{
LoadedPlugins.Add(newPlugin);
LoadedPlugins.Sort((s1, s2) => s1.CompareTo(s2));
}
}
public void InitializePlugins()
{
foreach (var pluginHost in LoadedPlugins.Where(lp => lp.Enabled))
{
foreach (var plugin in pluginHost.PluginHost.Plugins)
{
plugin.Initialize();
}
}
}
public void LoadPlugins()
{
Console.WriteLine("Loading plugins...");
Console.WriteLine();
var pluginFiles = Directory.GetFiles(PluginFolder);
var pluginTypes = new List <Type>();
for (int i = 0; i < pluginFiles.Length; i++)
{
try
{
if (Path.GetExtension(pluginFiles[i]) != ".dll")
{
continue;
}
Console.WriteLine("Loading {0}...", pluginFiles[i]);
var assembly = Assembly.LoadFrom(pluginFiles[i]);
var types = assembly.GetExportedTypes();
for (int j = 0; j < types.Length; j++)
{
if (m_PluginType.IsAssignableFrom(types[j]) && !types[j].IsAbstract)
{
var plugin = Activator.CreateInstance(types[j]) as Plugin;
Console.WriteLine("\tLoading {0}...", plugin.GetType().Name);
Console.WriteLine("\t\tName: {0}\n\t\tDescription: {1}\n\t\tAuthor: {2}", plugin.Name, plugin.Description, plugin.Author);
plugin.Client = m_Client;
LoadedPlugins.Add(plugin);
}
}
Console.WriteLine();
LoadedPluginAssemblies.Add(assembly);
}
catch (PluginException)
{
//TODO: Add logs.
//TODO: Remove plugin if the plugin was loaded.
Console.WriteLine("Error in plugin {0} constructor", pluginFiles[i]);
}
catch (Exception ex)
{
Console.WriteLine("Error while loading {0}: \n\t{1}", pluginFiles[i], ex.Message);
}
}
for (int i = 0; i < LoadedPlugins.Count; i++)
{
var pluginTasks = new PluginTasks(LoadedPlugins[i]);
m_PluginTasks.Add(pluginTasks);
pluginTasks.DoLoad();
}
}
public bool ImportPlugin(string pluginPath)
{
if (LoadedPlugins.Any(p => p.FullName == pluginPath))
{
return(true);
}
else
{
var plugin = new FileInfo(pluginPath);
LoadedPlugins.Add(plugin);
return(PluginManager.AddPlugin(plugin));
}
}
public Task <bool> ImportPlugin(string pluginPath)
{
if (LoadedPlugins.Any(p => p.FullName == pluginPath))
{
return(Task.FromResult(true));
}
else
{
var plugin = new FileInfo(pluginPath);
LoadedPlugins.Add(plugin);
return(Task.FromResult(PluginManager.AddPlugin(plugin)));
}
}
protected void LoadPlugins()
{
var pl = LoadedPlugins.ToList();
foreach (var item in Plugins)
{
foreach (var perm in item.Permissions)
{
if (WorkingPermissions.Contains(perm))
{
}
}
}
}
/// <summary>
/// Called when the plugin manager is unloading a plugin that was loaded by this plugin loader
/// </summary>
/// <param name="plugin_base"></param>
public override void Unloading(Plugin plugin_base)
{
var plugin = plugin_base as CSharpPlugin;
LoadedPlugins.Remove(plugin.Name);
// Unload plugins which require this plugin first
foreach (var compilable_plugin in plugins.Values)
{
if (compilable_plugin.Requires.Contains(plugin.Name))
{
Interface.Oxide.UnloadPlugin(compilable_plugin.Name);
}
}
}
/// <summary>
/// See interface docs.
/// </summary>
public void LoadPlugins()
{
var log = Factory.Singleton.Resolve <ILog>().Singleton;
var manifestStorage = Factory.Singleton.Resolve <IPluginManifestStorage>();
var applicationVersion = Factory.Singleton.Resolve <IApplicationInformation>().Version;
var rootFolder = Path.Combine(Provider.ApplicationStartupPath, "Plugins");
if (Provider.DirectoryExists(rootFolder))
{
foreach (var subFolder in Provider.DirectoryGetDirectories(rootFolder))
{
foreach (var dllFileName in Provider.DirectoryGetFiles(subFolder, "VirtualRadar.Plugin.*.dll"))
{
if (ManifestAllowsLoad(manifestStorage, applicationVersion, dllFileName))
{
try {
var pluginTypes = Provider.LoadTypes(dllFileName).Where(t => t.IsClass && typeof(IPlugin).IsAssignableFrom(t)).ToList();
if (pluginTypes.Count != 1)
{
IgnoredPlugins.Add(dllFileName, Strings.PluginDoesNotHaveJustOneIPlugin);
continue;
}
var pluginType = pluginTypes[0];
var plugin = (IPlugin)Activator.CreateInstance(pluginType);
plugin.PluginFolder = subFolder;
var snapshot = Provider.ClassFactoryTakeSnapshot();
try {
plugin.RegisterImplementations(Factory.Singleton);
LoadedPlugins.Add(plugin);
} catch {
Provider.ClassFactoryRestoreSnapshot(snapshot);
throw;
}
} catch (Exception ex) {
var exceptionMessage = FormatException(ex);
Debug.WriteLine(String.Format("PluginManager.LoadPlugins caught exception: {0}", exceptionMessage));
log.WriteLine("Caught exception loading plugin {0}: {1}", dllFileName, exceptionMessage);
IgnoredPlugins.Add(dllFileName, String.Format(Strings.PluginCannotBeLoaded, ex.Message));
}
}
}
}
}
}
/// <inheritdoc />
public override void OnDialogOpened(IDialogParameters parameters)
{
var title = parameters.GetValue <string>(LoadedPluginsDialogParameterNames.Title);
if (title != null)
{
Title = title;
}
var loadedPlugins = parameters.GetValue <IEnumerable <PluginViewModel> >(LoadedPluginsDialogParameterNames.LoadedPlugins);
if (loadedPlugins != null)
{
LoadedPlugins.Clear();
LoadedPlugins.AddRange(loadedPlugins);
}
}
/// <summary>
/// See interface docs.
/// </summary>
public void RegisterOwinMiddleware()
{
var log = Factory.ResolveSingleton <ILog>();
foreach (var plugin in LoadedPlugins.ToArray())
{
if (plugin is IPlugin_V2 v2Plugin)
{
try {
v2Plugin.RegisterOwinMiddleware();
} catch (Exception ex) {
log.WriteLine($"Caught exception registering web pipelines for plugin {v2Plugin.Name}: {FormatException(ex)}");
}
}
}
}
private void LoadPlugin(IPlugin plugin)
{
var savePlugin = $"{plugin.Name}_{plugin.Author}";
if (LoadedPlugins.Contains(plugin))
{
LoadedPlugins.Remove(plugin);
Options.Values.LoadedPlugins.Remove(savePlugin);
Options.Values.Save();
plugin.Unload();
return;
}
LoadedPlugins.Add(plugin);
Options.Values.LoadedPlugins.Add(savePlugin);
Options.Values.Save();
plugin.Load();
}
public void Load(CompilablePlugin plugin)
{
plugin.Compile(compiled =>
{
if (!compiled)
{
PluginLoadingCompleted(plugin);
return;
}
var loadedLoadingRequirements = plugin.Requires.Where(r => LoadedPlugins.ContainsKey(r) && LoadingPlugins.Contains(r));
foreach (var loadedPlugin in loadedLoadingRequirements)
{
Interface.Oxide.UnloadPlugin(loadedPlugin);
}
var missingRequirements = plugin.Requires.Where(r => !LoadedPlugins.ContainsKey(r));
if (missingRequirements.Any())
{
var loadingRequirements = plugin.Requires.Where(r => LoadingPlugins.Contains(r));
if (loadingRequirements.Any())
{
Interface.Oxide.LogDebug($"{plugin.Name} plugin is waiting for requirements to be loaded: {loadingRequirements.ToSentence()}");
}
else
{
Interface.Oxide.LogError($"{plugin.Name} plugin requires missing dependencies: {missingRequirements.ToSentence()}");
PluginErrors[plugin.Name] = $"Missing dependencies: {missingRequirements.ToSentence()}";
PluginLoadingCompleted(plugin);
}
}
else
{
Interface.Oxide.UnloadPlugin(plugin.Name);
plugin.LoadPlugin(pl =>
{
if (pl != null)
{
LoadedPlugins[pl.Name] = pl;
}
PluginLoadingCompleted(plugin);
});
}
});
}
public async Task SaveBoardPluginSetting(string boardKey, string pluginPath, JObject settings)
{
var plugin = LoadedPlugins.FirstOrDefault(x => x.PluginPath == pluginPath);
if (plugin == null)
{
throw new InvalidOperationException("Not found plugin");
}
else if (!plugin.HasBoardSetting)
{
throw new InvalidOperationException("This plugin cannot has settings.");
}
var path = GetPluginBoardSettingPath(boardKey, pluginPath);
var saveTask = File.WriteAllTextAsync(path, settings.ToString());
plugin.BoardSetting[boardKey] = settings.ToObject <object>();
await saveTask;
}
private void ExportExistingVisits()
{
using (Client = CreateConnectedClient())
{
new Exporter
{
Context = Context,
Client = Client,
ReferencePointCache = ReferencePointCache,
ParameterIdLookup = ParameterIdLookup,
MethodLookup = MethodLookup,
Plugins = LoadedPlugins
.Select(lp => lp.Plugin)
.ToList(),
}
.Run();
}
}
public void LoadPlugin(Assembly plugin, bool start = false)
{
if (plugin == null)
{
return;
}
var types = plugin.GetTypes();
foreach (var pin in from type in types where !type.IsInterface && !type.IsAbstract where type.HasAbstract(typeof(Plugin)) select(Plugin) Activator.CreateInstance(type))
{
Logger.Info(string.Format("Loading Plugin - {0}(V -> {1})", pin.Name, pin.Version), "Plugin Engine");
if (start)
{
pin.Start();
}
LoadedPlugins.Add(pin);
break;
}
}
/// <summary>
/// Called when the plugin manager is unloading a plugin that was loaded by this plugin loader
/// </summary>
/// <param name="pluginBase"></param>
public override void Unloading(Plugin pluginBase)
{
CSharpPlugin plugin = pluginBase as CSharpPlugin;
if (plugin == null)
{
return;
}
LoadedPlugins.Remove(plugin.Name);
// Unload plugins which require this plugin first
foreach (CompilablePlugin compilablePlugin in plugins.Values)
{
if (compilablePlugin.Requires.Contains(plugin.Name))
{
Interface.Oxide.UnloadPlugin(compilablePlugin.Name);
}
}
}
/// <summary>
/// See interface docs.
/// </summary>
public void RegisterImplementations()
{
var log = Factory.ResolveSingleton <ILog>();
foreach (var plugin in LoadedPlugins.ToArray())
{
var snapshot = Provider.ClassFactoryTakeSnapshot();
try {
plugin.RegisterImplementations(Factory.Singleton);
} catch (Exception ex) {
Provider.ClassFactoryRestoreSnapshot(snapshot);
var dllFileName = _PluginIDToFileNameMap[plugin.Id];
_PluginIDToFileNameMap.Remove(plugin.Id);
LoadedPlugins.Remove(plugin);
IgnoredPlugins.Add(dllFileName, String.Format(Strings.PluginCannotBeLoaded, ex.Message));
log.WriteLine("Caught exception loading plugin {0}: {1}", dllFileName, FormatException(ex));
}
}
}
public async void RunPlugins(PluginTypes types, Board board, Thread thread, Response response, Session session)
{
var targetPlugin = LoadedPlugins.Where(x => (x.PluginType & types) == types &&
x.IsEnabled &&
x.Valid &&
x.ActivatedBoards.Contains(board.BoardKey))
.OrderBy(x => x.Priority);
foreach (var item in targetPlugin)
{
try
{
await item.Script.RunAsync(new ZerochSharpPlugin(board, thread, response, types,
item.BoardSetting?[board.BoardKey] as dynamic, session));
}
catch (CompilationErrorException ex)
{
Console.WriteLine("Error in plugin running.");
Console.WriteLine(ex.Message);
var plugin = LoadedPlugins.FirstOrDefault(x => x.PluginPath == item.PluginPath);
if (plugin == null)
{
throw new InvalidOperationException();
}
plugin.Valid = false;
await SavePluginInfo();
Console.WriteLine($"Plugin {item.PluginName} is disabled.");
}
catch (Exception e)
{
throw new InvalidOperationException("error in running plugin", e);
}
}
}
public bool LoadPlugins()
{
LoadedPlugins.Clear();
foreach (string name in m_PluginNames)
{
IPlugin plugin = null;
try
{
plugin = (IPlugin)Activator.CreateInstance(Type.GetType(name));
}
catch (Exception)
{
return(false);
}
if (plugin != null)
{
LoadedPlugins.Add(plugin);
}
}
return(true);
}
public static PluginModel Find(string key)
{
return(LoadedPlugins?.Find(p => p.Key == key));
}
