protected override void OnDispose(bool inIsDisposing) { if (inIsDisposing) { if (_loader != null) { _loader.Release(); _loader = null; } } }
protected virtual PluginDomainInstanceLoader GetPluginInstanceLoader(string pluginConfigFilePath, string pluginFilePath) { if (string.IsNullOrEmpty(pluginConfigFilePath) || (PluginInstanceLoadersCacheTimeInMinutes <= 0)) { // This is not an expensive case with string.IsNullOrEmpty(pluginConfigFilePath), since we are // not creating spring objects, so don't cache // // OR // // we've specified to turn off the cache with PluginInstanceLoadersCacheTimeInMinutes <= 0 return(new PluginDomainInstanceLoader(pluginConfigFilePath, pluginFilePath)); } const string CACHED_PLUGIN_INSTANCE_LOADERS = "_CACHED_PLUGIN_INSTANCE_LOADERS"; string cacheName = CACHED_PLUGIN_INSTANCE_LOADERS + "_" + pluginConfigFilePath + "_" + pluginFilePath; PluginDomainInstanceLoader loader; lock (s_CachedPluginInstanceLoadersLock) { loader = HttpRuntime.Cache[cacheName] as PluginDomainInstanceLoader; } if (loader != null) { return(loader); } string parentDirPath = Path.GetDirectoryName(Path.GetDirectoryName(pluginFilePath)); loader = new PluginDomainInstanceLoader(pluginConfigFilePath, pluginFilePath); PluginDomainInstanceLoader loaderAlreadyThere = null; lock (s_CachedPluginInstanceLoadersLock) { loaderAlreadyThere = HttpRuntime.Cache[cacheName] as PluginDomainInstanceLoader; if (loaderAlreadyThere == null) { loader.Acquire(); HttpRuntime.Cache.Add(cacheName, loader, new CacheDependency(parentDirPath), Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(PluginInstanceLoadersCacheTimeInMinutes), CacheItemPriority.AboveNormal, OnCachePluginDomainInstanceLoaderRemovedCallback); } } if (loaderAlreadyThere != null) { // Switch over to already cached instance DisposableBase.SafeDispose(ref loader); loader = loaderAlreadyThere; } return(loader); }
public virtual void GetDataServiceParameters(IEnumerable <DataService> dataServices) { if (CollectionUtils.IsNullOrEmpty(dataServices)) { return; } try { string pluginRootFilePath = GetPluginFilePath(CollectionUtils.FirstItem(dataServices), true); PluginDomainInstanceLoader loader = GetPluginInstanceLoader(null, pluginRootFilePath); using (PluginDisposer disposer = new PluginDisposer(loader)) { foreach (DataService dataService in dataServices) { if ((dataService.PluginInfo != null) && !string.IsNullOrEmpty(dataService.PluginInfo.ImplementingClassName)) { try { string pluginFilePath = GetPluginFilePath(dataService, true); BaseWNOSPlugin plugin = loader.GetInstance <BaseWNOSPlugin>(pluginFilePath, dataService.PluginInfo.ImplementingClassName); DataServicePublishFlags publishFlags; dataService.ServiceParameters = plugin.GetDataServiceParameters(dataService.Name, out publishFlags); dataService.PublishFlags = publishFlags; } catch (Exception e) { // Don't publish on load error dataService.PublishFlags = DataServicePublishFlags.DoNotPublish; LOG.Error("Failed to GetDataServiceParameters for data service \"{0}\"", e, dataService.Name); } } else { // Don't publish if not implementer dataService.PublishFlags = DataServicePublishFlags.DoNotPublish; } } } } catch (Exception) { foreach (DataService dataService in dataServices) { // Don't publish if can't load dataService.PublishFlags = DataServicePublishFlags.DoNotPublish; } } }
protected virtual ICollection <SimpleDataService> GetDataServiceImplementersInDirectory(string inDirectoryPath, bool ignoreInstallingAssemblies) { OrderedSet <SimpleDataService> implementers = new OrderedSet <SimpleDataService>(); if (Directory.Exists(inDirectoryPath)) { OrderedSet <string> processedAssemblies = new OrderedSet <string>(); PluginDomainInstanceLoader loader = null; try { PluginInstanceFinder pluginFinder = null; foreach (string dllPath in Directory.GetFiles(inDirectoryPath, "*.dll", SearchOption.AllDirectories)) { if (!ignoreInstallingAssemblies || !IsInstallingPluginAssemblyPath(dllPath)) { string assemblyName = Path.GetFileName(dllPath); if (!processedAssemblies.Contains(assemblyName)) { string assemblyPath = GetPluginFilePathInDirectory(assemblyName, inDirectoryPath, ignoreInstallingAssemblies); if (assemblyPath != null) { if (loader == null) { // Don't need to load spring objects here loader = GetPluginInstanceLoader(null, assemblyPath); pluginFinder = loader.GetInstance <PluginInstanceFinder>(); } GetDataServiceImplementers(pluginFinder, assemblyPath, ref implementers); } processedAssemblies.Add(assemblyName); } } } } finally { DisposableBase.SafeDispose(ref loader); } } return(implementers); }
protected virtual IPluginDisposer LoadPluginInterfaceInstance <T>(DataService inDataService, bool ignoreInstallingAssemblies, string pluginConfigFilePath, out T plugin) where T : class { string pluginFilePath = GetPluginFilePath(inDataService, ignoreInstallingAssemblies); PluginDomainInstanceLoader loader = GetPluginInstanceLoader(pluginConfigFilePath, pluginFilePath); PluginDisposer disposer = new PluginDisposer(loader); try { plugin = loader.GetInstance <T>(pluginFilePath, inDataService.PluginInfo.ImplementingClassName); } catch (Exception) { DisposableBase.SafeDispose(ref disposer); throw; } return(disposer); }
public PluginDisposer(PluginDomainInstanceLoader loader) { _loader = loader; _loader.Acquire(); }
protected virtual void OnCachePluginDomainInstanceLoaderRemovedCallback(string key, object value, CacheItemRemovedReason reason) { PluginDomainInstanceLoader loader = (PluginDomainInstanceLoader)value; loader.Release(); }