Moving to NInject, reimplemented most things. Some services aren't discovered properly yet

.gitlab-ci.yml

@@ -1,4 +1,4 @@
-image: mcr.microsoft.com/dotnet/sdk:6.0
+image: mcr.microsoft.com/dotnet/sdk:7.0
 
 stages:
   - build
@@ -69,8 +69,8 @@ publish-windows:
     - if: "$CI_COMMIT_TAG"
   image: scottyhardy/docker-wine
   before_script:
-    - choco install dotnet-6.0-runtime --version=6.0.4 -y
+    - choco install dotnet-runtime --version=7.0.2 -y
-    - choco install dotnet-6.0-sdk --version=6.0.202 -y
+    - choco install dotnet-sdk --version=7.0.102 -y
     - choco install innosetup -y
   artifacts:
     paths:

src/NadekoBot/Bot.cs

@@ -1,13 +1,16 @@
 #nullable disable
+using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.DependencyInjection;
 using NadekoBot.Common.Configs;
 using NadekoBot.Common.ModuleBehaviors;
 using NadekoBot.Db;
 using NadekoBot.Modules.Utility;
 using NadekoBot.Services.Database.Models;
+using Ninject;
+using Ninject.Extensions.Conventions;
+using Ninject.Infrastructure.Language;
 using System.Collections.Immutable;
 using System.Diagnostics;
-using System.Net;
 using System.Reflection;
 using RunMode = Discord.Commands.RunMode;
 
@@ -20,7 +23,7 @@ public sealed class Bot
     public DiscordSocketClient Client { get; }
     public ImmutableArray<GuildConfig> AllGuildConfigs { get; private set; }
 
-    private IServiceProvider Services { get; set; }
+    private IKernel Services { get; set; }
 
     public string Mention { get; private set; }
     public bool IsReady { get; private set; }
@@ -99,67 +102,69 @@ public sealed class Bot
             AllGuildConfigs = uow.GuildConfigs.GetAllGuildConfigs(startingGuildIdList).ToImmutableArray();
         }
 
-        var svcs = new ServiceCollection().AddTransient(_ => _credsProvider.GetCreds()) // bot creds
+        var kernel = new StandardKernel();
-                                          .AddSingleton(_credsProvider)
+
-                                          .AddSingleton(_db) // database
+        kernel.Bind<IBotCredentials>().ToMethod(_ => _credsProvider.GetCreds()).InTransientScope();
-                                          .AddSingleton(Client) // discord socket client
+
-                                          .AddSingleton(_commandService)
+        kernel.Bind<IBotCredsProvider>().ToConstant(_credsProvider).InSingletonScope();
-                                          // .AddSingleton(_interactionService)
+        kernel.Bind<DbService>().ToConstant(_db).InSingletonScope();
-                                          .AddSingleton(this)
+        kernel.Bind<DiscordSocketClient>().ToConstant(Client).InSingletonScope();
-                                          .AddSingleton<ISeria, JsonSeria>()
+        kernel.Bind<CommandService>().ToConstant(_commandService).InSingletonScope();
-                                          .AddSingleton<IConfigSeria, YamlSeria>()
+        kernel.Bind<Bot>().ToConstant(this).InSingletonScope();
-                                          .AddConfigServices()
+
+        kernel.Bind<ISeria>().To<JsonSeria>().InSingletonScope();
+        kernel.Bind<IConfigSeria>().To<YamlSeria>().InSingletonScope();
+        kernel.Bind<IMemoryCache>().ToConstant(new MemoryCache(new MemoryCacheOptions())).InSingletonScope();
+
+        kernel.AddConfigServices()
               .AddConfigMigrators()
-                                          .AddMemoryCache()
-                                          // music
               .AddMusic()
-                                          // cache
+              .AddCache(_creds)
-                                          .AddCache(_creds);
+              .AddHttpClients();
 
 
-        svcs.AddHttpClient();
-        svcs.AddHttpClient("memelist")
-            .ConfigurePrimaryHttpMessageHandler(() => new HttpClientHandler
-            {
-                AllowAutoRedirect = false
-            });
-        
-        svcs.AddHttpClient("google:search")
-            .ConfigurePrimaryHttpMessageHandler(() => new HttpClientHandler()
-            {
-                AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
-            });
-
         if (Environment.GetEnvironmentVariable("NADEKOBOT_IS_COORDINATED") != "1")
-            svcs.AddSingleton<ICoordinator, SingleProcessCoordinator>();
+        {
+            kernel.Bind<ICoordinator>().To<SingleProcessCoordinator>().InSingletonScope();
+        }
         else
         {
-            svcs.AddSingleton<RemoteGrpcCoordinator>()
+            kernel.Bind<ICoordinator, IReadyExecutor>().To<RemoteGrpcCoordinator>().InSingletonScope();
-                .AddSingleton<ICoordinator>(x => x.GetRequiredService<RemoteGrpcCoordinator>())
-                .AddSingleton<IReadyExecutor>(x => x.GetRequiredService<RemoteGrpcCoordinator>());
         }
 
-        svcs.Scan(scan => scan.FromAssemblyOf<IReadyExecutor>()
+        kernel.Bind(scan =>
-                              .AddClasses(classes => classes.AssignableToAny(
+        {
-                                      // services
+            var classes = scan.FromThisAssembly()
-                                      typeof(INService),
+                              .SelectAllClasses()
-
+                              .Where(c => (c.IsAssignableTo(typeof(INService))
-                                      // behaviours
+                                           || c.IsAssignableTo(typeof(IExecOnMessage))
-                                      typeof(IExecOnMessage),
+                                           || c.IsAssignableTo(typeof(IInputTransformer))
-                                      typeof(IInputTransformer),
+                                           || c.IsAssignableTo(typeof(IExecPreCommand))
-                                      typeof(IExecPreCommand),
+                                           || c.IsAssignableTo(typeof(IExecPostCommand))
-                                      typeof(IExecPostCommand),
+                                           || c.IsAssignableTo(typeof(IExecNoCommand)))
-                                      typeof(IExecNoCommand))
+                                          && !c.HasAttribute<DontAddToIocContainerAttribute>()
-                                                .WithoutAttribute<DontAddToIocContainerAttribute>()
 #if GLOBAL_NADEKO
-                                                .WithoutAttribute<NoPublicBotAttribute>()
+                                                && !c.HasAttribute<NoPublicBotAttribute>()
 #endif
-                              )
+                              );
-                              .AsSelfWithInterfaces()
+            classes
-                              .WithSingletonLifetime());
+                .BindAllInterfaces()
+                .Configure(c => c.InSingletonScope());
+
+            classes.BindToSelf()
+                   .Configure(c => c.InSingletonScope());
+        });
+
+        kernel.Bind<IServiceProvider>().ToConstant(kernel).InSingletonScope();
+
+        var services = kernel.GetServices(typeof(INService));
+        foreach (var s in services)
+        {
+            Console.WriteLine(s.GetType().FullName);
+        }
 
         //initialize Services
-        Services = svcs.BuildServiceProvider();
+        Services = kernel;
         Services.GetRequiredService<IBehaviorHandler>().Initialize();
         Services.GetRequiredService<CurrencyRewardService>();
 

src/NadekoBot/Common/Medusa/MedusaIoCKernelModule.cs

@@ -0,0 +1,50 @@
+using Ninject.Modules;
+using Ninject.Extensions.Conventions;
+using System.Reflection;
+
+namespace Nadeko.Medusa;
+
+public sealed class MedusaIoCKernelModule : NinjectModule
+{
+    private Assembly _a;
+    public override string Name { get; }
+
+    public MedusaIoCKernelModule(string name, Assembly a)
+    {
+        Name = name;
+        _a = a;
+    }
+
+    public override void Load()
+    {
+        // todo cehck for duplicate registrations with ninject.extensions.convention
+        Kernel.Bind(conf =>
+        {
+            var transient = conf.From(_a)
+                                .SelectAllClasses()
+                                .WithAttribute<svcAttribute>(x => x.Lifetime == Lifetime.Transient);
+            
+            transient.BindAllInterfaces().Configure(x => x.InTransientScope());
+            transient.BindToSelf().Configure(x => x.InTransientScope());
+
+            var singleton = conf.From(_a)
+                                .SelectAllClasses()
+                                .WithAttribute<svcAttribute>(x => x.Lifetime == Lifetime.Singleton);
+            
+            singleton.BindAllInterfaces().Configure(x => x.InSingletonScope());
+            singleton.BindToSelf().Configure(x => x.InSingletonScope());
+        });
+    }
+
+    public override void Unload()
+    {
+        // todo implement unload
+        // Kernel.Unbind();
+    }
+
+    public override void Dispose(bool disposing)
+    {
+        _a = null!;
+        base.Dispose(disposing);
+    }
+}

src/NadekoBot/Common/Medusa/MedusaLoaderService.cs

@@ -2,6 +2,8 @@
 using Microsoft.Extensions.DependencyInjection;
 using Nadeko.Medusa.Adapters;
 using NadekoBot.Common.ModuleBehaviors;
+using Ninject;
+using Ninject.Modules;
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
@@ -18,6 +20,7 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
     private readonly IBehaviorHandler _behHandler;
     private readonly IPubSub _pubSub;
     private readonly IMedusaConfigService _medusaConfig;
+    private readonly IKernel _kernel;
 
     private readonly ConcurrentDictionary<string, ResolvedMedusa> _resolved = new();
     private readonly SemaphoreSlim _lock = new SemaphoreSlim(1, 1);
@@ -29,17 +32,18 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
 
     private const string BASE_DIR = "data/medusae";
 
-    public MedusaLoaderService(CommandService cmdService,
+    public MedusaLoaderService(
-        IServiceProvider botServices,
+        CommandService cmdService,
+        IKernel kernel,
         IBehaviorHandler behHandler,
         IPubSub pubSub,
         IMedusaConfigService medusaConfig)
     {
         _cmdService = cmdService;
-        _botServices = botServices;
         _behHandler = behHandler;
         _pubSub = pubSub;
         _medusaConfig = medusaConfig;
+        _kernel = kernel;
 
         // has to be done this way to support this feature on sharded bots
         _pubSub.Sub(_loadKey, async name => await InternalLoadAsync(name));
@@ -80,6 +84,7 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
 
             toReturn.Add(new MedusaStats(name, resolvedData.Strings.GetDescription(culture), sneks));
         }
+
         return toReturn;
     }
 
@@ -194,7 +199,7 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
             if (LoadAssemblyInternal(safeName,
                     out var ctx,
                     out var snekData,
-                    out var services,
+                    out var kernelModule,
                     out var strings,
                     out var typeReaders))
             {
@@ -213,7 +218,7 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
                             await sub.Instance.InitializeAsync();
                         }
 
-                        var module = await LoadModuleInternalAsync(name, point, strings, services);
+                        var module = await LoadModuleInternalAsync(name, point, strings, kernelModule);
                         moduleInfos.Add(module);
                     }
                     catch (Exception ex)
@@ -224,7 +229,7 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
                     }
                 }
 
-                var execs = GetExecsInternal(snekData, strings, services);
+                var execs = GetExecsInternal(snekData, strings);
                 await _behHandler.AddRangeAsync(execs);
 
                 _resolved[name] = new(LoadContext: ctx,
@@ -232,13 +237,10 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
                     SnekInfos: snekData.ToImmutableArray(),
                     strings,
                     typeReaders,
-                    execs)
+                    execs,
-                {
+                    kernelModule);
-                    Services = services
-                };
 
 
-                services = null;
                 _medusaConfig.AddLoadedMedusa(safeName);
                 return MedusaLoadResult.Success;
             }
@@ -261,16 +263,18 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    private IReadOnlyCollection<ICustomBehavior> GetExecsInternal(IReadOnlyCollection<SnekInfo> snekData, IMedusaStrings strings, IServiceProvider services)
+    private IReadOnlyCollection<ICustomBehavior> GetExecsInternal(
+        IReadOnlyCollection<SnekInfo> snekData,
+        IMedusaStrings strings)
     {
         var behs = new List<ICustomBehavior>();
         foreach (var snek in snekData)
         {
-            behs.Add(new BehaviorAdapter(new(snek.Instance), strings, services));
+            behs.Add(new BehaviorAdapter(new(snek.Instance), strings, _kernel));
 
             foreach (var sub in snek.Subsneks)
             {
-                behs.Add(new BehaviorAdapter(new(sub.Instance), strings, services));
+                behs.Add(new BehaviorAdapter(new(sub.Instance), strings, _kernel));
             }
         }
 
@@ -308,7 +312,7 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
         string safeName,
         [NotNullWhen(true)] out WeakReference<MedusaAssemblyLoadContext>? ctxWr,
         [NotNullWhen(true)] out IReadOnlyCollection<SnekInfo>? snekData,
-        out IServiceProvider services,
+        [NotNullWhen(true)] out INinjectModule? ninjectModule,
         out IMedusaStrings strings,
         out Dictionary<Type, TypeReader> typeReaders)
     {
@@ -319,11 +323,17 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
         strings = MedusaStrings.CreateDefault($"{BASE_DIR}/{safeName}");
         var ctx = new MedusaAssemblyLoadContext(Path.GetDirectoryName(path)!);
         var a = ctx.LoadFromAssemblyPath(Path.GetFullPath(path));
-        var sis = LoadSneksFromAssembly(a, out services);
+
-        typeReaders = LoadTypeReadersFromAssembly(a, strings, services);
+        // load services
+        ninjectModule = new MedusaIoCKernelModule(safeName, a);
+        _kernel.Load(ninjectModule);
+        
+        var sis = LoadSneksFromAssembly(safeName, a);
+        typeReaders = LoadTypeReadersFromAssembly(a, strings);
 
         if (sis.Count == 0)
         {
+            _kernel.Unload(safeName);
             return false;
         }
 
@@ -338,8 +348,7 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
     [MethodImpl(MethodImplOptions.NoInlining)]
     private Dictionary<Type, TypeReader> LoadTypeReadersFromAssembly(
         Assembly assembly,
-        IMedusaStrings strings,
+        IMedusaStrings strings)
-        IServiceProvider services)
     {
         var paramParsers = assembly.GetExportedTypes()
                                    .Where(x => x.IsClass
@@ -351,12 +360,12 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
         var typeReaders = new Dictionary<Type, TypeReader>();
         foreach (var parserType in paramParsers)
         {
-            var parserObj = ActivatorUtilities.CreateInstance(services, parserType);
+            var parserObj = ActivatorUtilities.CreateInstance(_kernel, parserType);
 
             var targetType = parserType.BaseType!.GetGenericArguments()[0];
             var typeReaderInstance = (TypeReader)Activator.CreateInstance(
                 typeof(ParamParserAdapter<>).MakeGenericType(targetType),
-                args: new[] { parserObj, strings, services })!;
+                args: new[] { parserObj, strings, _kernel })!;
 
             typeReaders.Add(targetType, typeReaderInstance);
         }
@@ -365,7 +374,11 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    private async Task<ModuleInfo> LoadModuleInternalAsync(string medusaName, SnekInfo snekInfo, IMedusaStrings strings, IServiceProvider services)
+    private async Task<ModuleInfo> LoadModuleInternalAsync(
+        string medusaName,
+        SnekInfo snekInfo,
+        IMedusaStrings strings,
+        INinjectModule services)
     {
         var module = await _cmdService.CreateModuleAsync(snekInfo.Instance.Prefix,
             CreateModuleFactory(medusaName, snekInfo, strings, services));
@@ -378,7 +391,7 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
         string medusaName,
         SnekInfo snekInfo,
         IMedusaStrings strings,
-        IServiceProvider medusaServices)
+        INinjectModule kernelModule)
         => mb =>
         {
             var m = mb.WithName(snekInfo.Name);
@@ -394,17 +407,17 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
                     CreateCallback(cmd.ContextType,
                         new(snekInfo),
                         new(cmd),
-                        new(medusaServices),
                         strings),
                     CreateCommandFactory(medusaName, cmd, strings));
             }
 
             foreach (var subInfo in snekInfo.Subsneks)
-                m.AddModule(subInfo.Instance.Prefix, CreateModuleFactory(medusaName, subInfo, strings, medusaServices));
+                m.AddModule(subInfo.Instance.Prefix, CreateModuleFactory(medusaName, subInfo, strings, kernelModule));
         };
 
     private static readonly RequireContextAttribute _reqGuild = new RequireContextAttribute(ContextType.Guild);
     private static readonly RequireContextAttribute _reqDm = new RequireContextAttribute(ContextType.DM);
+
     private Action<CommandBuilder> CreateCommandFactory(string medusaName, SnekCommandData cmd, IMedusaStrings strings)
         => (cb) =>
         {
@@ -466,19 +479,21 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
         CommandContextType contextType,
         WeakReference<SnekInfo> snekDataWr,
         WeakReference<SnekCommandData> snekCommandDataWr,
-        WeakReference<IServiceProvider> medusaServicesWr,
         IMedusaStrings strings)
-        => async (context, parameters, svcs, _) =>
+        => async (
+            context,
+            parameters,
+            svcs,
+            _) =>
         {
             if (!snekCommandDataWr.TryGetTarget(out var cmdData)
-                || !snekDataWr.TryGetTarget(out var snekData)
+                || !snekDataWr.TryGetTarget(out var snekData))
-                || !medusaServicesWr.TryGetTarget(out var medusaServices))
             {
                 Log.Warning("Attempted to run an unloaded snek's command");
                 return;
             }
 
-            var paramObjs = ParamObjs(contextType, cmdData, parameters, context, svcs, medusaServices, strings);
+            var paramObjs = ParamObjs(contextType, cmdData, parameters, context, svcs, _kernel, strings);
 
             try
             {
@@ -504,7 +519,6 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
                 cmdData = null;
 
                 snekData = null;
-                medusaServices = null;
             }
         };
 
@@ -574,10 +588,7 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
 
             var lc = lsi.LoadContext;
 
-            // removing this line will prevent assembly from being unloaded quickly
+            // lsi.KernelModule = null!;
-            // as this local variable will be held for a long time potentially
-            // due to how async works
-            lsi.Services = null!;
             lsi = null;
 
             _medusaConfig.RemoveLoadedMedusa(name);
@@ -653,25 +664,14 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
 
     private static readonly Type _snekType = typeof(Snek);
 
-    [MethodImpl(MethodImplOptions.NoInlining)]
+    // [MethodImpl(MethodImplOptions.NoInlining)]
-    private IServiceProvider LoadMedusaServicesInternal(Assembly a)
+    // private MedusaIoCKernelModule LoadMedusaServicesInternal(string name, Assembly a)
-        => new ServiceCollection()
+    //     => new MedusaIoCKernelModule(name, a);
-           .Scan(x => x.FromAssemblies(a)
-                       .AddClasses(static x => x.WithAttribute<svcAttribute>(x => x.Lifetime == Lifetime.Transient))
-                       .AsSelfWithInterfaces()
-                       .WithTransientLifetime()
-                       .AddClasses(static x => x.WithAttribute<svcAttribute>(x => x.Lifetime == Lifetime.Singleton))
-                       .AsSelfWithInterfaces()
-                       .WithSingletonLifetime())
-           .BuildServiceProvider();
 
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public IReadOnlyCollection<SnekInfo> LoadSneksFromAssembly(Assembly a, out IServiceProvider services)
+    public IReadOnlyCollection<SnekInfo> LoadSneksFromAssembly(string name, Assembly a)
     {
-        var medusaServices = LoadMedusaServicesInternal(a);
-        services = new MedusaServiceProvider(_botServices, medusaServices);
-        
         // find all types in teh assembly
         var types = a.GetExportedTypes();
         // snek is always a public non abstract class
@@ -690,7 +690,7 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
                 continue;
 
             // get module data, and add it to the topModules dictionary
-            var module = GetModuleData(cl, services);
+            var module = GetModuleData(cl);
             topModules.Add(cl, module);
         }
 
@@ -709,19 +709,19 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
                 continue;
             }
 
-            GetModuleData(c, services, parentData);
+            GetModuleData(c, parentData);
         }
 
         return topModules.Values.ToArray();
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    private SnekInfo GetModuleData(Type type, IServiceProvider services, SnekInfo? parentData = null)
+    private SnekInfo GetModuleData(Type type, SnekInfo? parentData = null)
     {
         var filters = type.GetCustomAttributes<FilterAttribute>(true)
                           .ToArray();
 
-        var instance = (Snek)ActivatorUtilities.CreateInstance(services, type);
+        var instance = (Snek)ActivatorUtilities.CreateInstance(_kernel, type);
 
         var module = new SnekInfo(instance.Name,
             parentData,
@@ -808,7 +808,9 @@ public sealed class MedusaLoaderService : IMedusaLoaderService, IReadyExecutor,
                 if (isContext)
                 {
                     if (hasDefaultValue || leftoverAttribute != null || isParams)
-                        throw new ArgumentException("IContext parameter cannot be optional, leftover, constant or params. " + GetErrorPath(method, pi));
+                        throw new ArgumentException(
+                            "IContext parameter cannot be optional, leftover, constant or params. "
+                            + GetErrorPath(method, pi));
 
                     if (paramCounter != 0)
                         throw new ArgumentException($"IContext parameter has to be first. {GetErrorPath(method, pi)}");

src/NadekoBot/Common/Medusa/MedusaServiceProvider.cs

@@ -1,24 +0,0 @@
-using System.Runtime.CompilerServices;
-
-namespace Nadeko.Medusa;
-
-public class MedusaServiceProvider : IServiceProvider
-{
-    private readonly IServiceProvider _nadekoServices;
-    private readonly IServiceProvider _medusaServices;
-
-    public MedusaServiceProvider(IServiceProvider nadekoServices, IServiceProvider medusaServices)
-    {
-        _nadekoServices = nadekoServices;
-        _medusaServices = medusaServices;
-    }
-
-    [MethodImpl(MethodImplOptions.NoInlining)]
-    public object? GetService(Type serviceType)
-    {
-        if (!serviceType.Assembly.IsCollectible)
-            return _nadekoServices.GetService(serviceType);
-
-        return _medusaServices.GetService(serviceType);
-    }
-}

src/NadekoBot/Common/Medusa/Models/ResolvedMedusa.cs

@@ -1,4 +1,5 @@
-using System.Collections.Immutable;
+using Ninject.Modules;
+using System.Collections.Immutable;
 
 namespace Nadeko.Medusa;
 
@@ -8,7 +9,7 @@ public sealed record ResolvedMedusa(
     IImmutableList<SnekInfo> SnekInfos,
     IMedusaStrings Strings,
     Dictionary<Type, TypeReader> TypeReaders,
-    IReadOnlyCollection<ICustomBehavior> Execs)
+    IReadOnlyCollection<ICustomBehavior> Execs,
+    INinjectModule KernelModule)
 {
-    public IServiceProvider Services { get; set; } = null!;
 }

src/NadekoBot/NadekoBot.csproj

@@ -47,8 +47,14 @@
         <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="7.0.0" />
         <PackageReference Include="MorseCode.ITask" Version="2.0.3" />
         <PackageReference Include="NetEscapades.Configuration.Yaml" Version="2.2.0" />
-        <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
+        
+        <!-- DI -->
+        <PackageReference Include="Ninject" Version="3.3.6" />
+        <PackageReference Include="Ninject.Extensions.Conventions" Version="3.3.0" />
+<!--        <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />-->
         <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="7.0.0" />
+<!--        <PackageReference Include="Scrutor" Version="4.2.0" />-->
+        
         <PackageReference Include="Microsoft.Extensions.Http" Version="7.0.0" />
         <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="7.0.0" />
         <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="7.0.0" />
@@ -56,7 +62,6 @@
         <PackageReference Include="Newtonsoft.Json" Version="13.0.2" />
         <PackageReference Include="NonBlocking" Version="2.1.1" />
         <PackageReference Include="OneOf" Version="3.0.223" />
-        <PackageReference Include="Scrutor" Version="4.2.0" />
         <PackageReference Include="Serilog.Sinks.Console" Version="4.1.0" />
         <PackageReference Include="Serilog.Sinks.Seq" Version="5.2.2" />
         <PackageReference Include="SixLabors.Fonts" Version="1.0.0-beta17" />

src/NadekoBot/Services/Impl/BehaviorExecutor.cs

@@ -1,6 +1,7 @@
 #nullable disable
 using Microsoft.Extensions.DependencyInjection;
 using NadekoBot.Common.ModuleBehaviors;
+using Ninject;
 
 namespace NadekoBot.Services;
 

src/NadekoBot/_Extensions/ReflectionExtensions.cs

@@ -0,0 +1,23 @@
+namespace NadekoBot.Extensions;
+
+public static class ReflectionExtensions
+{
+    public static bool IsAssignableToGenericType(this Type givenType, Type genericType)
+    {
+        var interfaceTypes = givenType.GetInterfaces();
+
+        foreach (var it in interfaceTypes)
+        {
+            if (it.IsGenericType && it.GetGenericTypeDefinition() == genericType)
+                return true;
+        }
+
+        if (givenType.IsGenericType && givenType.GetGenericTypeDefinition() == genericType)
+            return true;
+
+        Type baseType = givenType.BaseType;
+        if (baseType == null) return false;
+
+        return IsAssignableToGenericType(baseType, genericType);
+    }
+}

src/NadekoBot/_Extensions/ServiceCollectionExtensions.cs

@@ -1,76 +1,128 @@
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
 using NadekoBot.Modules.Music;
 using NadekoBot.Modules.Music.Resolvers;
 using NadekoBot.Modules.Music.Services;
+using Ninject;
+using Ninject.Extensions.Conventions;
 using StackExchange.Redis;
+using System.Net;
 using System.Reflection;
 
 namespace NadekoBot.Extensions;
 
 public static class ServiceCollectionExtensions
 {
-    public static IServiceCollection AddBotStringsServices(this IServiceCollection services, BotCacheImplemenation botCache)
+    public static IKernel AddBotStringsServices(this IKernel kernel, BotCacheImplemenation botCache)
-        => botCache == BotCacheImplemenation.Memory
-            ? services.AddSingleton<IStringsSource, LocalFileStringsSource>()
-                      .AddSingleton<IBotStringsProvider, MemoryBotStringsProvider>()
-                      .AddSingleton<IBotStrings, BotStrings>()
-            : services.AddSingleton<IStringsSource, LocalFileStringsSource>()
-                      .AddSingleton<IBotStringsProvider, RedisBotStringsProvider>()
-                      .AddSingleton<IBotStrings, BotStrings>();
-
-    public static IServiceCollection AddConfigServices(this IServiceCollection services)
     {
-        services.Scan(x => x.FromCallingAssembly()
+        if (botCache == BotCacheImplemenation.Memory)
-                            .AddClasses(f => f.AssignableTo(typeof(ConfigServiceBase<>)))
+        {
-                            .AsSelfWithInterfaces());
+            kernel.Bind<IStringsSource>().To<LocalFileStringsSource>().InSingletonScope();
-
+            kernel.Bind<IBotStringsProvider>().To<MemoryBotStringsProvider>().InSingletonScope();
-        return services;
+            kernel.Bind<IBotStrings>().To<BotStrings>().InSingletonScope();
+        }
+        else
+        {
+            kernel.Bind<IStringsSource>().To<LocalFileStringsSource>().InSingletonScope();
+            kernel.Bind<IBotStringsProvider>().To<RedisBotStringsProvider>().InSingletonScope();
+            kernel.Bind<IBotStrings>().To<BotStrings>().InSingletonScope();
         }
 
-    public static IServiceCollection AddConfigMigrators(this IServiceCollection services)
+        return kernel;
-        => services.AddSealedSubclassesOf(typeof(IConfigMigrator));
-
-    public static IServiceCollection AddMusic(this IServiceCollection services)
-        => services.AddSingleton<IMusicService, MusicService>()
-                   .AddSingleton<ITrackResolveProvider, TrackResolveProvider>()
-                   .AddSingleton<IYoutubeResolver, YtdlYoutubeResolver>()
-                   .AddSingleton<ISoundcloudResolver, SoundcloudResolver>()
-                   .AddSingleton<ILocalTrackResolver, LocalTrackResolver>()
-                   .AddSingleton<IRadioResolver, RadioResolver>()
-                   .AddSingleton<ITrackCacher, TrackCacher>()
-                   .AddSingleton<YtLoader>()
-                   .AddSingleton<IPlaceholderProvider>(svc => svc.GetRequiredService<IMusicService>());
-
-    // consider using scrutor, because slightly different versions
-    // of this might be needed in several different places
-    public static IServiceCollection AddSealedSubclassesOf(this IServiceCollection services, Type baseType)
-    {
-        var subTypes = Assembly.GetCallingAssembly()
-                               .ExportedTypes.Where(type => type.IsSealed && baseType.IsAssignableFrom(type));
-
-        foreach (var subType in subTypes)
-            services.AddSingleton(baseType, subType);
-
-        return services;
     }
 
-    public static IServiceCollection AddCache(this IServiceCollection services, IBotCredentials creds)
+    public static IKernel AddConfigServices(this IKernel kernel)
+    {
+        kernel.Bind(x =>
+        {
+            var configs = x.FromThisAssembly()
+                           .SelectAllClasses()
+                           .Where(f => f.IsAssignableToGenericType(typeof(ConfigServiceBase<>)));
+
+            // todo check for duplicates
+            configs.BindToSelf()
+                   .Configure(c => c.InSingletonScope());
+            configs.BindAllInterfaces()
+                   .Configure(c => c.InSingletonScope());
+        });
+
+        return kernel;
+    }
+
+    public static IKernel AddConfigMigrators(this IKernel kernel)
+        => kernel.AddSealedSubclassesOf(typeof(IConfigMigrator));
+
+    public static IKernel AddMusic(this IKernel kernel)
+    {
+        kernel.Bind<IMusicService, IPlaceholderProvider>()
+              .To<MusicService>()
+              .InSingletonScope();
+
+        kernel.Bind<ITrackResolveProvider>().To<TrackResolveProvider>().InSingletonScope();
+        kernel.Bind<IYoutubeResolver>().To<YtdlYoutubeResolver>().InSingletonScope();
+        kernel.Bind<ISoundcloudResolver>().To<SoundcloudResolver>().InSingletonScope();
+        kernel.Bind<ILocalTrackResolver>().To<LocalTrackResolver>().InSingletonScope();
+        kernel.Bind<IRadioResolver>().To<RadioResolver>().InSingletonScope();
+        kernel.Bind<ITrackCacher>().To<TrackCacher>().InSingletonScope();
+        kernel.Bind<YtLoader>().ToSelf().InSingletonScope();
+
+        return kernel;
+    }
+
+    public static IKernel AddSealedSubclassesOf(this IKernel kernel, Type baseType)
+    {
+        kernel.Bind(x =>
+        {
+            var classes = x.FromThisAssembly()
+                           .SelectAllClasses()
+                           .Where(c => c.IsPublic && c.IsNested && baseType.IsAssignableFrom(baseType));
+
+            classes.BindAllInterfaces().Configure(x => x.InSingletonScope());
+            classes.BindToSelf().Configure(x => x.InSingletonScope());
+        });
+
+        return kernel;
+    }
+
+    public static IKernel AddCache(this IKernel kernel, IBotCredentials creds)
     {
         if (creds.BotCache == BotCacheImplemenation.Redis)
         {
             var conf = ConfigurationOptions.Parse(creds.RedisOptions);
-            services.AddSingleton(ConnectionMultiplexer.Connect(conf))
+            kernel.Bind<ConnectionMultiplexer>().ToConstant(ConnectionMultiplexer.Connect(conf)).InSingletonScope();
-                    .AddSingleton<IBotCache, RedisBotCache>()
+            kernel.Bind<IBotCache>().To<RedisBotCache>().InSingletonScope();
-                    .AddSingleton<IPubSub, RedisPubSub>();
+            kernel.Bind<IPubSub>().To<RedisPubSub>().InSingletonScope();
         }
         else
         {
-            services.AddSingleton<IBotCache, MemoryBotCache>()
+            kernel.Bind<IBotCache>().To<MemoryBotCache>().InSingletonScope();
-                    .AddSingleton<IPubSub, EventPubSub>();
+            kernel.Bind<IPubSub>().To<EventPubSub>().InSingletonScope();
-
         }
 
-        return services
+        return kernel
             .AddBotStringsServices(creds.BotCache);
     }
+
+    public static IKernel AddHttpClients(this IKernel kernel)
+    {
+        IServiceCollection svcs = new ServiceCollection();
+        svcs.AddHttpClient();
+        svcs.AddHttpClient("memelist")
+            .ConfigurePrimaryHttpMessageHandler(() => new HttpClientHandler
+            {
+                AllowAutoRedirect = false
+            });
+
+        svcs.AddHttpClient("google:search")
+            .ConfigurePrimaryHttpMessageHandler(() => new HttpClientHandler()
+            {
+                AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
+            });
+
+        var prov = svcs.BuildServiceProvider();
+        kernel.Bind<IHttpClientFactory>().ToMethod(_ => prov.GetRequiredService<IHttpClientFactory>());
+        kernel.Bind<HttpClient>().ToMethod(_ => prov.GetRequiredService<HttpClient>());
+
+        return kernel;
+    }
 }