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;
 }
Beispiel #2
0
 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
         )
 {
 }
Beispiel #3
0
        /// <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;
 }
Beispiel #6
0
        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;
        }
Beispiel #8
0
 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;
        }
Beispiel #10
0
        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);
            }
        }
Beispiel #11
0
 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>();
        }
Beispiel #13
0
 // 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>();
 }
Beispiel #15
0
        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));
 }
Beispiel #17
0
 public IrcClient(IPEndPoint endPoint, string nickname, IPluginLogger logger, IPlugin plugin)
 {
     EndPoint = endPoint;
     _logger = logger;
     _plugin = plugin;
     Nickname = nickname.Replace(' ', '_');
     Start();
 }
Beispiel #18
0
 public IrcClient(IPEndPoint endPoint, string nickname, IPluginLogger logger, IPlugin plugin)
 {
     EndPoint = endPoint;
     _logger  = logger;
     _plugin  = plugin;
     Nickname = nickname.Replace(' ', '_');
     Start();
 }
Beispiel #19
0
        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));
 }
Beispiel #21
0
        /// <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;
        }
Beispiel #25
0
        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",
            };
        }
Beispiel #26
0
        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);
            }
        }
Beispiel #32
0
        /// <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);
        }