zydronium/screwturn-4
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fixed help files.

Browse source
This commit is contained in:
Dario Solera 2009-09-30 13:47:13 +00:00
commit b8f912cc79
1543 changed files with 395123 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

556
Core/ProviderLoader.cs Normal file
View file

@ -0,0 +1,556 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Reflection;
using ScrewTurn.Wiki.PluginFramework;
using System.Globalization;
namespace ScrewTurn.Wiki {
/// <summary>
/// Loads providers from assemblies.
/// </summary>
public static class ProviderLoader {
// These must be const because they are used in switch constructs
internal const string UsersProviderInterfaceName = "ScrewTurn.Wiki.PluginFramework.IUsersStorageProviderV30";
internal const string PagesProviderInterfaceName = "ScrewTurn.Wiki.PluginFramework.IPagesStorageProviderV30";
internal const string FilesProviderInterfaceName = "ScrewTurn.Wiki.PluginFramework.IFilesStorageProviderV30";
internal const string FormatterProviderInterfaceName = "ScrewTurn.Wiki.PluginFramework.IFormatterProviderV30";
internal const string CacheProviderInterfaceName = "ScrewTurn.Wiki.PluginFramework.ICacheProviderV30";
internal static string SettingsStorageProviderAssemblyName = "";
/// <summary>
/// Verifies the read-only/read-write constraints of providers.
/// </summary>
/// <typeparam name="T">The type of the provider.</typeparam>
/// <param name="provider">The provider.</param>
/// <exception cref="T:ProviderConstraintException">Thrown when a constraint is not fulfilled.</exception>
private static void VerifyConstraints<T>(T provider) {
if(typeof(T) == typeof(IUsersStorageProviderV30)) {
// If the provider allows to write user accounts data, then group membership must be writeable too
IUsersStorageProviderV30 actualInstance = (IUsersStorageProviderV30)provider;
if(!actualInstance.UserAccountsReadOnly && actualInstance.GroupMembershipReadOnly) {
throw new ProviderConstraintException("If UserAccountsReadOnly is false, then also GroupMembershipReadOnly must be false");
}
}
}
/// <summary>
/// Tries to inizialize a provider.
/// </summary>
/// <typeparam name="T">The type of the provider, which must implement <b>IProvider</b>.</typeparam>
/// <param name="instance">The provider instance to initialize.</param>
/// <param name="collectorEnabled">The collector for enabled providers.</param>
/// <param name="collectorDisabled">The collector for disabled providers.</param>
private static void Initialize<T>(T instance, ProviderCollector<T> collectorEnabled,
ProviderCollector<T> collectorDisabled) where T : class, IProviderV30 {
if(collectorEnabled.GetProvider(instance.GetType().FullName) != null ||
collectorDisabled.GetProvider(instance.GetType().FullName) != null) {
Log.LogEntry("Provider " + instance.Information.Name + " already in memory", EntryType.Warning, Log.SystemUsername);
return;
}
bool enabled = !IsDisabled(instance.GetType().FullName);
try {
if(enabled) {
instance.Init(Host.Instance, LoadConfiguration(instance.GetType().FullName));
}
}
catch(InvalidConfigurationException) {
// Disable Provider
enabled = false;
Log.LogEntry("Unable to load provider " + instance.Information.Name + " (configuration rejected), disabling it", EntryType.Error, Log.SystemUsername);
SaveStatus(instance.GetType().FullName, false);
}
catch {
// Disable Provider
enabled = false;
Log.LogEntry("Unable to load provider " + instance.Information.Name + " (unknown error), disabling it", EntryType.Error, Log.SystemUsername);
SaveStatus(instance.GetType().FullName, false);
throw; // Exception is rethrown because it's not a normal condition
}
if(enabled) collectorEnabled.AddProvider(instance);
else collectorDisabled.AddProvider(instance);
// Verify constraints
VerifyConstraints<T>(instance);
Log.LogEntry("Provider " + instance.Information.Name + " loaded (" + (enabled ? "Enabled" : "Disabled") + ")", EntryType.General, Log.SystemUsername);
}
/// <summary>
/// Loads all the Providers and initialises them.
/// </summary>
/// <param name="loadUsers">A value indicating whether to load users storage providers.</param>
/// <param name="loadPages">A value indicating whether to load pages storage providers.</param>
/// <param name="loadFiles">A value indicating whether to load files storage providers.</param>
/// <param name="loadFormatters">A value indicating whether to load formatter providers.</param>
/// <param name="loadCache">A value indicating whether to load cache providers.</param>
public static void FullLoad(bool loadUsers, bool loadPages, bool loadFiles, bool loadFormatters, bool loadCache) {
string[] pluginAssemblies = Settings.Provider.ListPluginAssemblies();
List<IUsersStorageProviderV30> users = new List<IUsersStorageProviderV30>(2);
List<IUsersStorageProviderV30> dUsers = new List<IUsersStorageProviderV30>(2);
List<IPagesStorageProviderV30> pages = new List<IPagesStorageProviderV30>(2);
List<IPagesStorageProviderV30> dPages = new List<IPagesStorageProviderV30>(2);
List<IFilesStorageProviderV30> files = new List<IFilesStorageProviderV30>(2);
List<IFilesStorageProviderV30> dFiles = new List<IFilesStorageProviderV30>(2);
List<IFormatterProviderV30> forms = new List<IFormatterProviderV30>(2);
List<IFormatterProviderV30> dForms = new List<IFormatterProviderV30>(2);
List<ICacheProviderV30> cache = new List<ICacheProviderV30>(2);
List<ICacheProviderV30> dCache = new List<ICacheProviderV30>(2);
for(int i = 0; i < pluginAssemblies.Length; i++) {
IFilesStorageProviderV30[] d;
IUsersStorageProviderV30[] u;
IPagesStorageProviderV30[] p;
IFormatterProviderV30[] f;
ICacheProviderV30[] c;
LoadFrom(pluginAssemblies[i], out u, out p, out d, out f, out c);
if(loadFiles) files.AddRange(d);
if(loadUsers) users.AddRange(u);
if(loadPages) pages.AddRange(p);
if(loadFormatters) forms.AddRange(f);
if(loadCache) cache.AddRange(c);
}
// Init and add to the Collectors, starting from files providers
for(int i = 0; i < files.Count; i++) {
Initialize<IFilesStorageProviderV30>(files[i], Collectors.FilesProviderCollector, Collectors.DisabledFilesProviderCollector);
}
for(int i = 0; i < users.Count; i++) {
Initialize<IUsersStorageProviderV30>(users[i], Collectors.UsersProviderCollector, Collectors.DisabledUsersProviderCollector);
}
for(int i = 0; i < pages.Count; i++) {
Initialize<IPagesStorageProviderV30>(pages[i], Collectors.PagesProviderCollector, Collectors.DisabledPagesProviderCollector);
}
for(int i = 0; i < forms.Count; i++) {
Initialize<IFormatterProviderV30>(forms[i], Collectors.FormatterProviderCollector, Collectors.DisabledFormatterProviderCollector);
}
for(int i = 0; i < cache.Count; i++) {
Initialize<ICacheProviderV30>(cache[i], Collectors.CacheProviderCollector, Collectors.DisabledCacheProviderCollector);
}
}
/// <summary>
/// Loads the Configuration data of a Provider.
/// </summary>
/// <param name="typeName">The Type Name of the Provider.</param>
/// <returns>The Configuration, if available, otherwise an empty string.</returns>
public static string LoadConfiguration(string typeName) {
return Settings.Provider.GetPluginConfiguration(typeName);
}
/// <summary>
/// Saves the Configuration data of a Provider.
/// </summary>
/// <param name="typeName">The Type Name of the Provider.</param>
/// <param name="config">The Configuration data to save.</param>
public static void SaveConfiguration(string typeName, string config) {
Settings.Provider.SetPluginConfiguration(typeName, config);
}
/// <summary>
/// Saves the Status of a Provider.
/// </summary>
/// <param name="typeName">The Type Name of the Provider.</param>
/// <param name="enabled">A value specifying whether or not the Provider is enabled.</param>
public static void SaveStatus(string typeName, bool enabled) {
Settings.Provider.SetPluginStatus(typeName, enabled);
}
/// <summary>
/// Returns a value specifying whether or not a Provider is disabled.
/// </summary>
/// <param name="typeName">The Type Name of the Provider.</param>
/// <returns>True if the Provider is disabled.</returns>
public static bool IsDisabled(string typeName) {
return !Settings.Provider.GetPluginStatus(typeName);
}
/// <summary>
/// Loads Providers from an assembly.
/// </summary>
/// <param name="assembly">The path of the Assembly to load the Providers from.</param>
public static int LoadFromAuto(string assembly) {
IUsersStorageProviderV30[] users;
IPagesStorageProviderV30[] pages;
IFilesStorageProviderV30[] files;
IFormatterProviderV30[] forms;
ICacheProviderV30[] cache;
LoadFrom(assembly, out users, out pages, out files, out forms, out cache);
int count = 0;
// Init and add to the Collectors, starting from files providers
for(int i = 0; i < files.Length; i++) {
Initialize<IFilesStorageProviderV30>(files[i], Collectors.FilesProviderCollector, Collectors.DisabledFilesProviderCollector);
count++;
}
for(int i = 0; i < users.Length; i++) {
Initialize<IUsersStorageProviderV30>(users[i], Collectors.UsersProviderCollector, Collectors.DisabledUsersProviderCollector);
count++;
}
for(int i = 0; i < pages.Length; i++) {
Initialize<IPagesStorageProviderV30>(pages[i], Collectors.PagesProviderCollector, Collectors.DisabledPagesProviderCollector);
count++;
}
for(int i = 0; i < forms.Length; i++) {
Initialize<IFormatterProviderV30>(forms[i], Collectors.FormatterProviderCollector, Collectors.DisabledFormatterProviderCollector);
count++;
}
for(int i = 0; i < cache.Length; i++) {
Initialize<ICacheProviderV30>(cache[i], Collectors.CacheProviderCollector, Collectors.DisabledCacheProviderCollector);
count++;
}
return count;
}
/// <summary>
/// Loads Providers from an assembly.
/// </summary>
/// <param name="assembly">The path of the Assembly to load the Providers from.</param>
/// <param name="users">The Users Providers.</param>
/// <param name="files">The Files Providers.</param>
/// <param name="pages">The Pages Providers.</param>
/// <param name="formatters">The Formatter Providers.</param>
/// <param name="cache">The Cache Providers.</param>
/// <remarks>The Components returned are <b>not</b> initialized.</remarks>
public static void LoadFrom(string assembly, out IUsersStorageProviderV30[] users, out IPagesStorageProviderV30[] pages,
out IFilesStorageProviderV30[] files, out IFormatterProviderV30[] formatters, out ICacheProviderV30[] cache) {
Assembly asm = null;
try {
//asm = Assembly.LoadFile(assembly);
// This way the DLL is not locked and can be deleted at runtime
asm = Assembly.Load(LoadAssemblyFromProvider(Path.GetFileName(assembly)));
}
catch {
files = new IFilesStorageProviderV30[0];
users = new IUsersStorageProviderV30[0];
pages = new IPagesStorageProviderV30[0];
formatters = new IFormatterProviderV30[0];
cache = new ICacheProviderV30[0];
Log.LogEntry("Unable to load assembly " + Path.GetFileNameWithoutExtension(assembly), EntryType.Error, Log.SystemUsername);
return;
}
Type[] types = null;
try {
types = asm.GetTypes();
}
catch(ReflectionTypeLoadException) {
files = new IFilesStorageProviderV30[0];
users = new IUsersStorageProviderV30[0];
pages = new IPagesStorageProviderV30[0];
formatters = new IFormatterProviderV30[0];
cache = new ICacheProviderV30[0];
Log.LogEntry("Unable to load providers from (probably v2) assembly " + Path.GetFileNameWithoutExtension(assembly), EntryType.Error, Log.SystemUsername);
return;
}
List<IUsersStorageProviderV30> urs = new List<IUsersStorageProviderV30>();
List<IPagesStorageProviderV30> pgs = new List<IPagesStorageProviderV30>();
List<IFilesStorageProviderV30> fls = new List<IFilesStorageProviderV30>();
List<IFormatterProviderV30> frs = new List<IFormatterProviderV30>();
List<ICacheProviderV30> che = new List<ICacheProviderV30>();
Type[] interfaces;
for(int i = 0; i < types.Length; i++) {
// Avoid to load abstract classes as they cannot be instantiated
if(types[i].IsAbstract) continue;
interfaces = types[i].GetInterfaces();
foreach(Type iface in interfaces) {
if(iface == typeof(IUsersStorageProviderV30)) {
IUsersStorageProviderV30 tmpu = CreateInstance<IUsersStorageProviderV30>(asm, types[i]);
if(tmpu != null) {
urs.Add(tmpu);
Collectors.FileNames[tmpu.GetType().FullName] = assembly;
}
}
if(iface == typeof(IPagesStorageProviderV30)) {
IPagesStorageProviderV30 tmpp = CreateInstance<IPagesStorageProviderV30>(asm, types[i]);
if(tmpp != null) {
pgs.Add(tmpp);
Collectors.FileNames[tmpp.GetType().FullName] = assembly;
}
}
if(iface == typeof(IFilesStorageProviderV30)) {
IFilesStorageProviderV30 tmpd = CreateInstance<IFilesStorageProviderV30>(asm, types[i]);
if(tmpd != null) {
fls.Add(tmpd);
Collectors.FileNames[tmpd.GetType().FullName] = assembly;
}
}
if(iface == typeof(IFormatterProviderV30)) {
IFormatterProviderV30 tmpf = CreateInstance<IFormatterProviderV30>(asm, types[i]);
if(tmpf != null) {
frs.Add(tmpf);
Collectors.FileNames[tmpf.GetType().FullName] = assembly;
}
}
if(iface == typeof(ICacheProviderV30)) {
ICacheProviderV30 tmpc = CreateInstance<ICacheProviderV30>(asm, types[i]);
if(tmpc != null) {
che.Add(tmpc);
Collectors.FileNames[tmpc.GetType().FullName] = assembly;
}
}
}
}
users = urs.ToArray();
pages = pgs.ToArray();
files = fls.ToArray();
formatters = frs.ToArray();
cache = che.ToArray();
}
/// <summary>
/// Creates an instance of a type implementing a provider interface.
/// </summary>
/// <typeparam name="T">The provider interface type.</typeparam>
/// <param name="asm">The assembly that contains the type.</param>
/// <param name="type">The type to create an instance of.</param>
/// <returns>The instance, or <c>null</c>.</returns>
private static T CreateInstance<T>(Assembly asm, Type type) where T : class, IProviderV30 {
T instance;
try {
instance = asm.CreateInstance(type.ToString()) as T;
return instance;
}
catch {
Log.LogEntry("Unable to create instance of " + type.ToString(), EntryType.Error, Log.SystemUsername);
throw;
}
}
/// <summary>
/// Loads the content of an assembly from disk.
/// </summary>
/// <param name="assembly">The assembly file full path.</param>
/// <returns>The content of the assembly, in a byte array form.</returns>
private static byte[] LoadAssemblyFromDisk(string assembly) {
return File.ReadAllBytes(assembly);
}
/// <summary>
/// Loads the content of an assembly from the settings provider.
/// </summary>
/// <param name="assemblyName">The name of the assembly, such as "Assembly.dll".</param>
/// <returns>The content fo the assembly.</returns>
private static byte[] LoadAssemblyFromProvider(string assemblyName) {
return Settings.Provider.RetrievePluginAssembly(assemblyName);
}
/// <summary>
/// Loads the proper Setting Storage Provider, given its name.
/// </summary>
/// <param name="name">The fully qualified name (such as "Namespace.ProviderClass, MyAssembly"), or <c>null</c>/<b>String.Empty</b>/"<b>default</b>" for the default provider.</param>
/// <returns>The settings storage provider.</returns>
public static ISettingsStorageProviderV30 LoadSettingsStorageProvider(string name) {
if(name == null || name.Length == 0 || string.Compare(name, "default", true, CultureInfo.InvariantCulture) == 0) {
return new SettingsStorageProvider();
}
ISettingsStorageProviderV30 result = null;
Exception inner = null;
if(name.Contains(",")) {
string[] fields = name.Split(',');
if(fields.Length == 2) {
fields[0] = fields[0].Trim(' ', '"');
fields[1] = fields[1].Trim(' ', '"');
try {
// assemblyName should be an absolute path or a relative path in bin or public\Plugins
Assembly asm;
Type t;
string assemblyName = fields[1];
if(!assemblyName.ToLowerInvariant().EndsWith(".dll")) assemblyName += ".dll";
if(File.Exists(assemblyName)) {
asm = Assembly.Load(LoadAssemblyFromDisk(assemblyName));
t = asm.GetType(fields[0]);
SettingsStorageProviderAssemblyName = Path.GetFileName(assemblyName);
}
else {
string tentativePluginsPath = null;
try {
// Settings.PublicDirectory is only available when running the web app
tentativePluginsPath = Path.Combine(Settings.PublicDirectory, "Plugins");
tentativePluginsPath = Path.Combine(tentativePluginsPath, assemblyName);
}
catch { }
if(!string.IsNullOrEmpty(tentativePluginsPath) && File.Exists(tentativePluginsPath)) {
asm = Assembly.Load(LoadAssemblyFromDisk(tentativePluginsPath));
t = asm.GetType(fields[0]);
SettingsStorageProviderAssemblyName = Path.GetFileName(tentativePluginsPath);
}
else {
// Trim .dll
t = Type.GetType(fields[0] + "," + assemblyName.Substring(0, assemblyName.Length - 4), true, true);
SettingsStorageProviderAssemblyName = assemblyName;
}
}
result = t.GetConstructor(new Type[0]).Invoke(new object[0]) as ISettingsStorageProviderV30;
}
catch(Exception ex) {
inner = ex;
result = null;
}
}
}
if(result == null) throw new ArgumentException("Could not load the specified Settings Storage Provider", inner);
else return result;
}
/// <summary>
/// Loads all settings storage providers available in all DLLs stored in a provider.
/// </summary>
/// <param name="repository">The input provider.</param>
/// <returns>The providers found (not initialized).</returns>
public static ISettingsStorageProviderV30[] LoadAllSettingsStorageProviders(ISettingsStorageProviderV30 repository) {
// This method is actually a memory leak because it can be executed multimple times
// Every time it loads a set of assemblies which cannot be unloaded (unless a separate AppDomain is used)
List<ISettingsStorageProviderV30> result = new List<ISettingsStorageProviderV30>();
foreach(string dll in repository.ListPluginAssemblies()) {
byte[] asmBin = repository.RetrievePluginAssembly(dll);
Assembly asm = Assembly.Load(asmBin);
Type[] types = null;
try {
types = asm.GetTypes();
}
catch(ReflectionTypeLoadException) {
// Skip assembly
Log.LogEntry("Unable to load providers from (probably v2) assembly " + Path.GetFileNameWithoutExtension(dll), EntryType.Error, Log.SystemUsername);
continue;
}
foreach(Type type in types) {
// Avoid to load abstract classes as they cannot be instantiated
if(type.IsAbstract) continue;
Type[] interfaces = type.GetInterfaces();
foreach(Type iface in interfaces) {
if(iface == typeof(ISettingsStorageProviderV30)) {
try {
ISettingsStorageProviderV30 temp = asm.CreateInstance(type.ToString()) as ISettingsStorageProviderV30;
if(temp != null) result.Add(temp);
}
catch { }
}
}
}
}
return result.ToArray();
}
/// <summary>
/// Tries to change a provider's configuration.
/// </summary>
/// <param name="typeName">The provider.</param>
/// <param name="configuration">The new configuration.</param>
/// <param name="error">The error message, if any.</param>
/// <returns><c>true</c> if the configuration is saved, <c>false</c> if the provider rejected it.</returns>
public static bool TryChangeConfiguration(string typeName, string configuration, out string error) {
error = null;
bool enabled, canDisable;
IProviderV30 provider = Collectors.FindProvider(typeName, out enabled, out canDisable);
try {
provider.Init(Host.Instance, configuration);
}
catch(InvalidConfigurationException icex) {
error = icex.Message;
return false;
}
SaveConfiguration(typeName, configuration);
return true;
}
/// <summary>
/// Disables a provider.
/// </summary>
/// <param name="typeName">The provider to disable.</param>
public static void DisableProvider(string typeName) {
bool enabled, canDisable;
IProviderV30 provider = Collectors.FindProvider(typeName, out enabled, out canDisable);
if(enabled && canDisable) {
provider.Shutdown();
Collectors.TryDisable(typeName);
SaveStatus(typeName, false);
}
}
/// <summary>
/// Enables a provider.
/// </summary>
/// <param name="typeName">The provider to enable.</param>
public static void EnableProvider(string typeName) {
bool enabled, canDisable;
IProviderV30 provider = Collectors.FindProvider(typeName, out enabled, out canDisable);
if(!enabled) {
provider.Init(Host.Instance, LoadConfiguration(typeName));
Collectors.TryEnable(typeName);
SaveStatus(typeName, true);
}
}
/// <summary>
/// Unloads a provider from memory.
/// </summary>
/// <param name="typeName">The provider to unload.</param>
public static void UnloadProvider(string typeName) {
DisableProvider(typeName);
Collectors.TryUnload(typeName);
}
}
/// <summary>
/// Defines an exception thrown when a constraint is not fulfilled by a provider.
/// </summary>
public class ProviderConstraintException : Exception {
/// <summary>
/// Initializes a new instance of the <see cref="T:ProviderConstraintException" /> class.
/// </summary>
/// <param name="message">The message.</param>
public ProviderConstraintException(string message)
: base(message) { }
}
}