public DefaultAssemblyLoaderWithNativeResolver( IPluginLogger <T> logger, IAssemblyLoadOptions <T> options, IHostFrameworkProvider hostFrameworkProvider, IHostTypesProvider <T> hostTypesProvider, IDowngradableDependenciesProvider <T> downgradableDependenciesProvider, IRemoteTypesProvider <T> remoteTypesProvider, IDependencyPathProvider <T> dependencyPathProvider, IProbingPathsProvider <T> probingPathsProvider, IRuntimePlatformContext runtimePlatformContext, IDepsFileProvider <T> depsFileProvider, IPluginDependencyResolver <T> pluginDependencyResolver, INativeAssemblyUnloader nativeAssemblyUnloader, IAssemblyLoadStrategyProvider assemblyLoadStrategyProvider) : base() { this.logger = logger; this.options = options; this.hostFrameworkProvider = hostFrameworkProvider; this.hostTypesProvider = hostTypesProvider; this.downgradableDependenciesProvider = downgradableDependenciesProvider; this.remoteTypesProvider = remoteTypesProvider; this.dependencyPathProvider = dependencyPathProvider; this.probingPathsProvider = probingPathsProvider; this.runtimePlatformContext = runtimePlatformContext; this.depsFileProvider = depsFileProvider; this.pluginDependencyResolver = pluginDependencyResolver; this.nativeAssemblyUnloader = nativeAssemblyUnloader; this.assemblyLoadStrategyProvider = assemblyLoadStrategyProvider; }
public DefaultAssemblyLoadContextWithNativeResolver( IPluginLogger <T> logger, IAssemblyLoadOptions <T> options, IHostFrameworkProvider hostFrameworkProvider, IHostTypesProvider <T> hostTypesProvider, IDowngradableDependenciesProvider <T> downgradableDependenciesProvider, IRemoteTypesProvider <T> remoteTypesProvider, IDependencyPathProvider <T> dependencyPathProvider, IProbingPathsProvider <T> probingPathsProvider, IRuntimePlatformContext runtimePlatformContext, IDepsFileProvider <T> depsFileProvider, IPluginDependencyResolver <T> pluginDependencyResolver, INativeAssemblyUnloader nativeAssemblyUnloader, IAssemblyLoadStrategyProvider assemblyLoadStrategyProvider ) : base( logger, options, hostFrameworkProvider, hostTypesProvider, downgradableDependenciesProvider, remoteTypesProvider, dependencyPathProvider, probingPathsProvider, runtimePlatformContext, depsFileProvider, pluginDependencyResolver, nativeAssemblyUnloader, assemblyLoadStrategyProvider ) { }
/// <summary> /// Instantiates a new instance of the <see cref="Connection" /> class. /// </summary> /// <param name="dispatcher">A message dispatcher.</param> /// <param name="sender">A sender.</param> /// <param name="receiver">A receiver.</param> /// <param name="options">Connection options.</param> /// <param name="logger">A plugin logger.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="dispatcher" /> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="sender" /> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="receiver" /> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="options" /> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="logger" /> is <c>null</c>.</exception> internal Connection(IMessageDispatcher dispatcher, ISender sender, IReceiver receiver, ConnectionOptions options, IPluginLogger logger) { if (dispatcher == null) { throw new ArgumentNullException(nameof(dispatcher)); } if (sender == null) { throw new ArgumentNullException(nameof(sender)); } if (receiver == null) { throw new ArgumentNullException(nameof(receiver)); } if (options == null) { throw new ArgumentNullException(nameof(options)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } MessageDispatcher = dispatcher; _sender = sender; _receiver = receiver; Options = options; _logger = logger; MessageDispatcher.SetConnection(this); }
public FunctionPluginLoaderOptions( IPluginLoadOptions <IHelloPlugin> helloPluginLoadOptions, IPluginLogger <IHelloPlugin> pluginLogger, IPluginPathProvider <IHelloPlugin> pluginPathProvider, IHostTypesProvider <IHelloPlugin> hostTypesProvider, IRemoteTypesProvider <IHelloPlugin> remoteTypesProvider, IRuntimePlatformContext runtimePlatformContext, IHostFrameworkProvider hostFrameworkProvider, IDependencyPathProvider <IHelloPlugin> dependencyPathProvider, IProbingPathsProvider <IHelloPlugin> probingPathsProvider, IPluginDependencyResolver <IHelloPlugin> pluginDependencyResolver, INativeAssemblyUnloader nativeAssemblyUnloader, ITempPathProvider <IHelloPlugin> tempPathProvider, IAssemblyLoadStrategyProvider assemblyLoadStrategyProvider, IPluginServerOptions pluginServerOptions, IHttpClientFactory httpFactory) { this.helloPluginLoadOptions = helloPluginLoadOptions; this.pluginLogger = pluginLogger; this.pluginPathProvider = pluginPathProvider; this.hostTypesProvider = hostTypesProvider; this.remoteTypesProvider = remoteTypesProvider; this.runtimePlatformContext = runtimePlatformContext; this.hostFrameworkProvider = hostFrameworkProvider; this.dependencyPathProvider = dependencyPathProvider; this.probingPathsProvider = probingPathsProvider; this.pluginDependencyResolver = pluginDependencyResolver; this.nativeAssemblyUnloader = nativeAssemblyUnloader; this.tempPathProvider = tempPathProvider; this.assemblyLoadStrategyProvider = assemblyLoadStrategyProvider; this.pluginServerOptions = pluginServerOptions; this.httpFactory = httpFactory; }
public NetworkAssemblyLoadContext( IPluginLogger <T> logger, INetworkAssemblyLoaderOptions <T> options, IHostFrameworkProvider hostFrameworkProvider, IHostTypesProvider <T> hostTypesProvider, IRemoteTypesProvider <T> remoteTypesProvider, IDependencyPathProvider <T> dependencyPathProvider, IProbingPathsProvider <T> probingPathsProvider, IRuntimePlatformContext runtimePlatformContext, IDepsFileProvider <T> depsFileProvider, IPluginDependencyResolver <T> pluginDependencyResolver, INativeAssemblyUnloader nativeAssemblyUnloader, IAssemblyLoadStrategyProvider assemblyLoadStrategyProvider, IHttpClientFactory httpClientFactory, ITempPathProvider <T> tempPathProvider) : base( logger, options, hostFrameworkProvider, hostTypesProvider, remoteTypesProvider, dependencyPathProvider, probingPathsProvider, runtimePlatformContext, depsFileProvider, pluginDependencyResolver, nativeAssemblyUnloader, assemblyLoadStrategyProvider ) { this.httpClient = httpClientFactory.CreateClient(); this.baseUrl = options.BaseUrl; this.tempPathProvider = tempPathProvider; }
public PluginSettings(string pluginName, IPluginLogger logger) { Logger = logger; try { Logger.AddLog("InitSettings starting"); RegistryKey Key = Registry.CurrentUser.OpenSubKey(@"Software", true); Key = Key.CreateSubKey("TaskbarIconHost"); if (pluginName != null) { SettingKey = Key.CreateSubKey("Settings-" + pluginName); } else { SettingKey = Key.CreateSubKey("Main Settings"); } Logger.AddLog("InitSettings done"); } catch (Exception e) { Logger.AddLog($"(from InitSettings) {e.Message}"); } }
/// <summary> /// Initializes a new <see cref="InboundRequestContext" /> class. /// </summary> /// <param name="connection">A connection.</param> /// <param name="requestId">A request ID.</param> /// <param name="cancellationToken">A cancellation token.</param> /// <param name="logger">A plugin logger.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="connection" /> /// is <c>null</c>.</exception> /// <exception cref="ArgumentException">Thrown if <paramref name="requestId" /> /// is either <c>null</c> or an empty string.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="logger" /> /// is <c>null</c>.</exception> internal InboundRequestContext( IConnection connection, string requestId, CancellationToken cancellationToken, IPluginLogger logger) { if (connection == null) { throw new ArgumentNullException(nameof(connection)); } if (string.IsNullOrEmpty(requestId)) { throw new ArgumentException(Strings.ArgumentCannotBeNullOrEmpty, nameof(requestId)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } _connection = connection; RequestId = requestId; _cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); // Capture the cancellation token now because if the cancellation token source // is disposed race conditions may cause an exception acccessing its Token property. _cancellationToken = _cancellationTokenSource.Token; _logger = logger; }
public NetworkAssemblyLoader( IPluginLogger <T> logger, INetworkAssemblyLoaderOptions <T> options, IHostFrameworkProvider hostFrameworkProvider, IHostTypesProvider <T> hostTypesProvider, IRemoteTypesProvider <T> remoteTypesProvider, IDependencyPathProvider <T> dependencyPathProvider, IProbingPathsProvider <T> probingPathsProvider, IRuntimePlatformContext runtimePlatformContext, IDepsFileProvider <T> depsFileProvider, IPluginDependencyResolver <T> pluginDependencyResolver, INativeAssemblyUnloader nativeAssemblyUnloader, IAssemblyLoadStrategyProvider assemblyLoadStrategyProvider, ITempPathProvider <T> tempPathProvider, IHttpClientFactory httpClientFactory ) { this.logger = logger; this.options = options; this.hostFrameworkProvider = hostFrameworkProvider; this.hostTypesProvider = hostTypesProvider; this.remoteTypesProvider = remoteTypesProvider; this.dependencyPathProvider = dependencyPathProvider; this.probingPathsProvider = probingPathsProvider; this.runtimePlatformContext = runtimePlatformContext; this.depsFileProvider = depsFileProvider; this.pluginDependencyResolver = pluginDependencyResolver; this.nativeAssemblyUnloader = nativeAssemblyUnloader; this.assemblyLoadStrategyProvider = assemblyLoadStrategyProvider; this.tempPathProvider = tempPathProvider; this.httpClientFactory = httpClientFactory; }
/// <summary> /// Instantiates a new <see cref="MessageDispatcher" /> class. /// </summary> /// <param name="requestHandlers">Request handlers.</param> /// <param name="idGenerator">A unique identifier generator.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="requestHandlers" /> /// is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="idGenerator" /> /// is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="inboundRequestProcessingHandler" /> /// is <c>null</c>.</exception> /// /// <exception cref="ArgumentNullException">Thrown if <paramref name="logger" /> /// is <c>null</c>.</exception> internal MessageDispatcher(IRequestHandlers requestHandlers, IIdGenerator idGenerator, InboundRequestProcessingHandler inboundRequestProcessingHandler, IPluginLogger logger) { if (requestHandlers == null) { throw new ArgumentNullException(nameof(requestHandlers)); } if (idGenerator == null) { throw new ArgumentNullException(nameof(idGenerator)); } if (inboundRequestProcessingHandler == null) { throw new ArgumentNullException(nameof(inboundRequestProcessingHandler)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } RequestHandlers = requestHandlers; _idGenerator = idGenerator; _logger = logger; _inboundRequestContexts = new ConcurrentDictionary <string, InboundRequestContext>(); _outboundRequestContexts = new ConcurrentDictionary <string, OutboundRequestContext>(); _inboundRequestProcessingContext = inboundRequestProcessingHandler; }
private static void LoadAssemblyAndReferencesFromCurrentAppDomain(IPluginLogger logger, string assemblyFileName, List <HostDependency> hostDependencies, IEnumerable <Type> downgradableTypes, IEnumerable <string> downgradableAssemblies) { var assemblyName = new AssemblyName(assemblyFileName); if (assemblyFileName == null || hostDependencies.Any(h => h.DependencyName.Name == assemblyName.Name)) { return; // Break condition } hostDependencies.Add(new HostDependency { DependencyName = assemblyName, AllowDowngrade = downgradableTypes.Any(t => t.Assembly.GetName().Name == assemblyName.Name) || downgradableAssemblies.Any(a => a == assemblyName.Name) }); try { var assembly = AssemblyLoadContext.Default.LoadFromAssemblyName(assemblyName); foreach (var reference in assembly.GetReferencedAssemblies()) { LoadAssemblyAndReferencesFromCurrentAppDomain(logger, reference, hostDependencies, downgradableTypes, downgradableAssemblies); } } catch (FileNotFoundException) { // This happens when the assembly is a platform assembly, log it logger.LoadReferenceFromAppDomainFailed(assemblyName); } }
public IAssemblyLoadStrategy ProvideAssemblyLoadStrategy( IPluginLogger logger, IPluginLoadContext pluginLoadContext, IPluginDependencyContext pluginDependencyContext) { return(new DefaultAssemblyLoadStrategy(logger, pluginLoadContext, pluginDependencyContext)); }
public DefaultAssemblyLoadContext( IPluginLogger <T> logger, IAssemblyLoadOptions <T> options, IHostFrameworkProvider hostFrameworkProvider, IHostTypesProvider <T> hostTypesProvider, IDowngradableDependenciesProvider <T> downgradableDependenciesProvider, IRemoteTypesProvider <T> remoteTypesProvider, IDependencyPathProvider <T> dependencyPathProvider, IProbingPathsProvider <T> probingPathsProvider, IRuntimePlatformContext runtimePlatformContext, IDepsFileProvider <T> depsFileProvider, IPluginDependencyResolver <T> pluginDependencyResolver, INativeAssemblyUnloader nativeAssemblyUnloader, IAssemblyLoadStrategyProvider assemblyLoadStrategyProvider) #if NETCORE3_0 || NETCORE3_1 : base(options.UseCollectibleAssemblies) #endif { this.logger = logger; this.options = options; this.hostFrameworkProvider = hostFrameworkProvider; this.hostTypesProvider = hostTypesProvider; this.downgradableDependenciesProvider = downgradableDependenciesProvider; this.remoteTypesProvider = remoteTypesProvider; this.dependencyPathProvider = dependencyPathProvider; this.probingPathsProvider = probingPathsProvider; this.runtimePlatformContext = runtimePlatformContext; this.depsFileProvider = depsFileProvider; this.pluginDependencyResolver = pluginDependencyResolver; this.nativeAssemblyUnloader = nativeAssemblyUnloader; this.assemblyLoadStrategyProvider = assemblyLoadStrategyProvider; this.loadedNativeLibraries = new ConcurrentDictionary <string, IntPtr>(); this.loadedPlugins = new ConcurrentBag <string>(); this.assemblyReferences = new ConcurrentBag <WeakReference>(); }
// Use the ASP.NET Core DI system to inject these dependencies public PluginLoadOptions( IPluginLogger <T> logger, IAssemblyScanner <T> assemblyScanner, ISharedServicesProvider <T> sharedServicesProvider, IPluginTypesProvider <T> pluginTypesProvider, IPluginActivationContextProvider <T> pluginActivationContextProvider, IRemotePluginActivator <T> activator, IParameterConverter parameterConverter, IResultConverter resultConverter, IPluginAssemblyLoader <T> assemblyLoader, IPluginProxyCreator <T> proxyCreator, IHostTypesProvider <T> hostTypesProvider, IRemoteTypesProvider <T> remoteTypesProvider, IRuntimePlatformContext runtimePlatformContext, IAssemblySelector <T> assemblySelector, IPluginSelector <T> pluginSelector ) { this.logger = logger; this.assemblyScanner = assemblyScanner; this.sharedServicesProvider = sharedServicesProvider; this.pluginTypesProvider = pluginTypesProvider; this.pluginActivationContextProvider = pluginActivationContextProvider; this.activator = activator; this.parameterConverter = parameterConverter; this.resultConverter = resultConverter; this.assemblyLoader = assemblyLoader; this.proxyCreator = proxyCreator; this.hostTypesProvider = hostTypesProvider; this.remoteTypesProvider = remoteTypesProvider; this.runtimePlatformContext = runtimePlatformContext; this.assemblySelector = assemblySelector; this.pluginSelector = pluginSelector; }
public DefaultAssemblyLoadContext( IPluginLogger <T> logger, IAssemblyLoadOptions <T> options, IHostFrameworkProvider hostFrameworkProvider, IHostTypesProvider <T> hostTypesProvider, IRemoteTypesProvider <T> remoteTypesProvider, IDependencyPathProvider <T> dependencyPathProvider, IProbingPathsProvider <T> probingPathsProvider, IRuntimePlatformContext runtimePlatformContext, IDepsFileProvider <T> depsFileProvider, IPluginDependencyResolver <T> pluginDependencyResolver, INativeAssemblyUnloader nativeAssemblyUnloader, IAssemblyLoadStrategyProvider assemblyLoadStrategyProvider) { this.logger = logger; this.options = options; this.hostFrameworkProvider = hostFrameworkProvider; this.hostTypesProvider = hostTypesProvider; this.remoteTypesProvider = remoteTypesProvider; this.dependencyPathProvider = dependencyPathProvider; this.probingPathsProvider = probingPathsProvider; this.runtimePlatformContext = runtimePlatformContext; this.depsFileProvider = depsFileProvider; this.pluginDependencyResolver = pluginDependencyResolver; this.nativeAssemblyUnloader = nativeAssemblyUnloader; this.assemblyLoadStrategyProvider = assemblyLoadStrategyProvider; this.loadedNativeLibraries = new ConcurrentDictionary <string, IntPtr>(); this.loadedPlugins = new ConcurrentBag <string>(); }
private static void LoadAssemblyAndReferencesFromCurrentAppDomain(IPluginLogger logger, AssemblyName assemblyName, List <HostDependency> hostDependencies) { if (assemblyName?.Name == null || hostDependencies.Any(h => h.DependencyName.Name == assemblyName.Name)) { return; // Break condition } hostDependencies.Add(new HostDependency { DependencyName = assemblyName }); try { var assembly = AssemblyLoadContext.Default.LoadFromAssemblyName(assemblyName); foreach (var reference in assembly.GetReferencedAssemblies()) { LoadAssemblyAndReferencesFromCurrentAppDomain(logger, reference, hostDependencies); } } catch (FileNotFoundException) { // This happens when the assembly is a platform assembly, log it logger.LoadReferenceFromAppDomainFailed(assemblyName); } }
private static void WriteCommonLogMessages(IPluginLogger logger) { logger.Write(new AssemblyLogMessage(logger.Now)); logger.Write(new MachineLogMessage(logger.Now)); logger.Write(new EnvironmentVariablesLogMessage(logger.Now)); logger.Write(new ProcessLogMessage(logger.Now)); logger.Write(new ThreadPoolLogMessage(logger.Now)); }
public IrcClient(IPEndPoint endPoint, string nickname, IPluginLogger logger, IPlugin plugin) { EndPoint = endPoint; _logger = logger; _plugin = plugin; Nickname = nickname.Replace(' ', '_'); Start(); }
public static async Task <PluginDependencyContext> FromPluginAssemblyAsync <T>( IPluginLoadContext pluginLoadContext, IPluginLogger <T> pluginLogger, IHostFrameworkProvider hostFrameworkProvider, IEnumerable <Type> hostTypes, IEnumerable <string> hostAssemblies, IEnumerable <Type> downgradableTypes, IEnumerable <string> downgradablehostAssemblies, IEnumerable <Type> remoteTypes, IRuntimePlatformContext runtimePlatformContext, IDepsFileProvider <T> depsFileProvider, bool ignorePlatformInconsistencies) { var hostDependencies = new List <HostDependency>(); var remoteDependencies = new List <RemoteDependency>(); foreach (var type in hostTypes) { // Load host types from current app domain LoadAssemblyAndReferencesFromCurrentAppDomain(pluginLogger, type.Assembly.GetName(), hostDependencies, downgradableTypes, downgradablehostAssemblies); } foreach (var assemblyFileName in hostAssemblies) { // Load host types from current app domain LoadAssemblyAndReferencesFromCurrentAppDomain(pluginLogger, assemblyFileName, hostDependencies, downgradableTypes, downgradablehostAssemblies); } foreach (var type in remoteTypes) { remoteDependencies.Add(new RemoteDependency { DependencyName = type.Assembly.GetName() }); } var hostFramework = hostFrameworkProvider.ProvideHostFramwork(); var dependencyContext = await GetDependencyContextFromPluginAssemblyAsync(pluginLoadContext, depsFileProvider); var pluginFramework = dependencyContext.Target.Framework; CheckFrameworkCompatibility(hostFramework, pluginFramework, ignorePlatformInconsistencies); var pluginDependencies = GetPluginDependencies(dependencyContext); var resoureDependencies = GetResourceDependencies(dependencyContext); var platformDependencies = GetPlatformDependencies(dependencyContext, runtimePlatformContext.GetPlatformExtensions()); var pluginReferenceDependencies = GetPluginReferenceDependencies(dependencyContext); return(new PluginDependencyContext( pluginLoadContext, hostDependencies, remoteDependencies, pluginDependencies, pluginReferenceDependencies, resoureDependencies, platformDependencies)); }
public DefaultAssemblyLoadStrategy( IPluginLogger logger, IPluginLoadContext pluginLoadContext, IPluginDependencyContext pluginDependencyContext) { this.logger = logger.ThrowIfNull(nameof(logger)); this.pluginLoadContext = pluginLoadContext.ThrowIfNull(nameof(pluginLoadContext)); this.pluginDependencyContext = pluginDependencyContext.ThrowIfNull(nameof(pluginDependencyContext)); }
/// <summary> /// Initializes a new instance of the <see cref="Plugin" /> class. /// </summary> /// <param name="applicationPaths">The application paths.</param> /// <param name="xmlSerializer">The XML serializer.</param> /// <param name="httpClient">The HTTP client.</param> /// <param name="jsonSerializer">The json serializer.</param> /// <param name="networkManager">The network manager.</param> /// <param name="logger">The logger.</param> public Plugin( IApplicationPaths applicationPaths, IXmlSerializer xmlSerializer, IHttpClient httpClient, IJsonSerializer jsonSerializer, INetworkManager networkManager, ILogger logger, TmdbLookup tmdbLookup) : base(applicationPaths, xmlSerializer) { Instance = this; Logger = new PluginLogger(logger); // Create our shared service proxies StreamingProxy = new StreamingServiceProxy(httpClient, jsonSerializer, xmlSerializer, networkManager); TvProxy = new TVServiceProxy(httpClient, jsonSerializer, xmlSerializer, StreamingProxy, tmdbLookup); }
/// <summary> /// Instantiates a new <see cref="PluginFactory" /> class. /// </summary> /// <param name="pluginIdleTimeout">The plugin idle timeout.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="pluginIdleTimeout" /> /// is less than <see cref="Timeout.InfiniteTimeSpan" />.</exception> public PluginFactory(TimeSpan pluginIdleTimeout) { if (pluginIdleTimeout < Timeout.InfiniteTimeSpan) { throw new ArgumentOutOfRangeException( nameof(pluginIdleTimeout), pluginIdleTimeout, Strings.Plugin_IdleTimeoutMustBeGreaterThanOrEqualToInfiniteTimeSpan); } _logger = PluginLogger.DefaultInstance; _pluginIdleTimeout = pluginIdleTimeout; _plugins = new ConcurrentDictionary <string, Lazy <Task <IPlugin> > >(); }
public T CreateInstance(IPluginLogger Logger = null) { try { System.Reflection.Assembly Asm = System.Reflection.Assembly.LoadFrom(DynamicLinkLibraryPath); T ModuleInstance = (T)Asm.CreateInstance(InstanceTypeName); return(ModuleInstance); } catch (Exception ex) { Logger?.Warn("new instance create failed! : {0}", ex); return(null); } }
/// <summary> /// Initializes a new <see cref="OutboundRequestContext{TResult}" /> class. /// </summary> /// <param name="connection">A connection.</param> /// <param name="request">A request.</param> /// <param name="timeout">An optional request timeout.</param> /// <param name="isKeepAlive">A flag indicating whether or not the request supports progress notifications /// to reset the request timeout.</param> /// <param name="cancellationToken">A cancellation token.</param> /// <param name="logger">A plugin logger.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="connection" /> /// is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="request" /> /// is <c>null</c>.</exception> /// <exception cref="OperationCanceledException">Thrown if <paramref name="cancellationToken" /> /// is cancelled.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="logger" /> /// is <c>null</c>.</exception> internal OutboundRequestContext( IConnection connection, Message request, TimeSpan?timeout, bool isKeepAlive, CancellationToken cancellationToken, IPluginLogger logger) { if (connection == null) { throw new ArgumentNullException(nameof(connection)); } if (request == null) { throw new ArgumentNullException(nameof(request)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } _connection = connection; _request = request; _taskCompletionSource = new TaskCompletionSource <TResult>(TaskCreationOptions.RunContinuationsAsynchronously); _timeout = timeout; _isKeepAlive = isKeepAlive; RequestId = request.RequestId; if (timeout.HasValue) { _timer = new Timer( OnTimeout, state: null, dueTime: timeout.Value, period: Timeout.InfiniteTimeSpan); } _cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); _logger = logger; _cancellationTokenSource.Token.Register(TryCancel); // Capture the cancellation token now because if the cancellation token source // is disposed race conditions may cause an exception acccessing its Token property. CancellationToken = _cancellationTokenSource.Token; }
private void SetupPlugin(ICreateGameCallInfo info) { var config = (string)info.Request.GameProperties[ConfigKey]; callAfter = config.Contains("After"); callBefore = config.Contains("Before"); continueInCallback = config.Contains("ContinueInCallback"); this.logger = this.PluginHost.CreateLogger(typeof(AllMethosCallHttpTestPlugin).FullName); this.logger.Warn("Got next config '" + config + "' for game:" + info.Request.GameId); request = new HttpRequest { Async = config.Contains("Async"), Url = "https://wt-e4c18d407aa73a40e4182aaf00a2a2eb-0.run.webtask.io/realtime-webhooks-1.2/GameEvent", }; }
public PluginSettings(string pluginName, IPluginLogger logger) { PluginName = pluginName; Logger = logger; try { Logger.AddLog("InitSettings starting"); OpenPluginKey(); Logger.AddLog("InitSettings done"); } catch (Exception e) { Logger.AddLog($"(from InitSettings) {e.Message}"); } }
static public AssemblyMetadata <T>[] GetMetadatas(string DllFilePath, IPluginLogger Logger = null) { if (!File.Exists(DllFilePath)) { Logger?.Warn("not found DLL path! : {0}", DllFilePath); return(null); } List <AssemblyMetadata <T> > MetadataResults = new List <AssemblyMetadata <T> >(); try { System.Reflection.Assembly Asm = System.Reflection.Assembly.LoadFrom(DllFilePath); MetadataResults.AddRange(GetMetadatas(Asm, Logger)); } catch (Exception ex) { Logger?.Warn("has exception! : {0}", ex); } return(MetadataResults.ToArray()); }
static public AssemblyMetadata <T>[] SearchMetadata(string[] Paths, IPluginLogger Logger = null) { List <AssemblyMetadata <T> > MetadataResults = new List <AssemblyMetadata <T> >(); string InterfaceName = typeof(T).FullName; foreach (string SearchPath in Paths) { if (!Directory.Exists(SearchPath)) { Logger?.Warn("not found search path! : {0}", SearchPath); continue; } string[] Dlls = Directory.GetFiles(SearchPath, "*.dll", SearchOption.AllDirectories); foreach (string Dll in Dlls) { AssemblyMetadata <T>[] Result = GetMetadatas(Dll, Logger); if (Result != null) { MetadataResults.AddRange(Result); } } } return(MetadataResults.ToArray()); }
public PluginLoadOptionsBuilder <T> WithLogger(IPluginLogger <T> logger) { this.logger = logger; return(this); }
private static void CreatePluginList(Assembly pluginAssembly, List <Type> PluginClientTypeList, Guid embeddedPluginGuid, IPluginLogger logger, out List <IPluginClient> PluginList) { PluginList = new List <IPluginClient>(); foreach (Type ClientType in PluginClientTypeList) { try { object PluginHandle = pluginAssembly.CreateInstance(ClientType.FullName); if (PluginHandle != null) { string PluginName = PluginHandle.GetType().InvokeMember(nameof(IPluginClient.Name), BindingFlags.Default | BindingFlags.GetProperty, null, PluginHandle, null) as string; Guid PluginGuid = (Guid)PluginHandle.GetType().InvokeMember(nameof(IPluginClient.Guid), BindingFlags.Default | BindingFlags.GetProperty, null, PluginHandle, null); bool PluginRequireElevated = (bool)PluginHandle.GetType().InvokeMember(nameof(IPluginClient.RequireElevated), BindingFlags.Default | BindingFlags.GetProperty, null, PluginHandle, null); bool PluginHasClickHandler = (bool)PluginHandle.GetType().InvokeMember(nameof(IPluginClient.HasClickHandler), BindingFlags.Default | BindingFlags.GetProperty, null, PluginHandle, null); if (!string.IsNullOrEmpty(PluginName) && PluginGuid != Guid.Empty) { bool createdNew; EventWaitHandle InstanceEvent; if (PluginGuid != embeddedPluginGuid) { InstanceEvent = new EventWaitHandle(false, EventResetMode.ManualReset, GuidToString(PluginGuid), out createdNew); } else { createdNew = true; InstanceEvent = null; } if (createdNew) { IPluginClient NewPlugin = new PluginClient(PluginHandle, PluginName, PluginGuid, PluginRequireElevated, PluginHasClickHandler, InstanceEvent); PluginList.Add(NewPlugin); } else { logger.AddLog("Another instance of a plugin is already running"); InstanceEvent.Close(); InstanceEvent = null; } } } } catch { } } }
public static bool Init(bool isElevated, string embeddedPluginName, Guid embeddedPluginGuid, Dispatcher dispatcher, IPluginLogger logger) { PluginInterfaceType = typeof(IPluginClient); Assembly CurrentAssembly = Assembly.GetExecutingAssembly(); string Location = CurrentAssembly.Location; string AppFolder = Path.GetDirectoryName(Location); int AssemblyCount = 0; int CompatibleAssemblyCount = 0; Dictionary <Assembly, List <Type> > PluginClientTypeTable = new Dictionary <Assembly, List <Type> >(); Assembly PluginAssembly; List <Type> PluginClientTypeList; if (embeddedPluginName != null) { AssemblyName[] AssemblyNames = CurrentAssembly.GetReferencedAssemblies(); foreach (AssemblyName name in AssemblyNames) { if (name.Name == embeddedPluginName) { FindPluginClientTypesByName(name, out PluginAssembly, out PluginClientTypeList); if (PluginAssembly != null && PluginClientTypeList != null && PluginClientTypeList.Count > 0) { PluginClientTypeTable.Add(PluginAssembly, PluginClientTypeList); } } } } string[] Assemblies = Directory.GetFiles(AppFolder, "*.dll"); foreach (string AssemblyPath in Assemblies) { FindPluginClientTypesByPath(AssemblyPath, out PluginAssembly, out PluginClientTypeList); if (PluginAssembly != null && PluginClientTypeList != null) { PluginClientTypeTable.Add(PluginAssembly, PluginClientTypeList); } } foreach (KeyValuePair <Assembly, List <Type> > Entry in PluginClientTypeTable) { AssemblyCount++; PluginAssembly = Entry.Key; PluginClientTypeList = Entry.Value; if (PluginClientTypeList.Count > 0) { CompatibleAssemblyCount++; CreatePluginList(PluginAssembly, PluginClientTypeList, embeddedPluginGuid, logger, out List <IPluginClient> PluginList); if (PluginList.Count > 0) { LoadedPluginTable.Add(PluginAssembly, PluginList); } } } if (LoadedPluginTable.Count > 0) { foreach (KeyValuePair <Assembly, List <IPluginClient> > Entry in LoadedPluginTable) { foreach (IPluginClient Plugin in Entry.Value) { IPluginSettings Settings = new PluginSettings(GuidToString(Plugin.Guid), logger); Plugin.Initialize(isElevated, dispatcher, Settings, logger); if (Plugin.RequireElevated) { RequireElevated = true; } } } foreach (KeyValuePair <Assembly, List <IPluginClient> > Entry in LoadedPluginTable) { foreach (IPluginClient Plugin in Entry.Value) { List <ICommand> PluginCommandList = Plugin.CommandList; if (PluginCommandList != null) { List <ICommand> FullPluginCommandList = new List <ICommand>(); FullCommandList.Add(FullPluginCommandList, Plugin.Name); foreach (ICommand Command in PluginCommandList) { FullPluginCommandList.Add(Command); if (Command != null) { CommandTable.Add(Command, Plugin); } } } Icon PluginIcon = Plugin.Icon; if (PluginIcon != null) { ConsolidatedPluginList.Add(Plugin); } } } foreach (IPluginClient Plugin in ConsolidatedPluginList) { if (Plugin.HasClickHandler) { PreferredPlugin = Plugin; break; } } if (PreferredPlugin == null && ConsolidatedPluginList.Count > 0) { PreferredPlugin = ConsolidatedPluginList[0]; } return(true); } else { logger.AddLog($"Could not load plugins, {AssemblyCount} assemblies found, {CompatibleAssemblyCount} are compatible."); return(false); } }
/// <summary> /// Called after all default plugins are loaded, at which point it is safe to assume that any dependencies are loaded. /// </summary> public void Initialize() { _logger = Server.GetPluginLogger(); _logger.Log(LogLevel.Info, Name, "Initialize ircplugin Version {0}.", Version); _logger.Log(LogLevel.Debug, Name, "Checking folder {0}", ConfigurationDirectory); if (!Directory.Exists(ConfigurationDirectory)) { Directory.CreateDirectory(ConfigurationDirectory); } _logger.Log(LogLevel.Debug, Name, "Checking configfile {0}", ConfigurationFilename); if (!File.Exists(ConfigurationFilename)) { GenerateNewConfigurationFile(); } LoadConfigurationFile(); _serverListener = new IrcPluginServerListener(this); }