Squidex.Identity and Setting per Host

Eddyjl · February 18, 2020, 7:37pm

Is it possible to use Squidex Identity to connect to more than one app?

Now it is not possible since the configuration is in the appsetting.json

would like to inject this configuration or load it base on the URL.

thank you.

Sebastian · February 18, 2020, 8:44pm

What behavior do you expect?

Eddyjl · February 18, 2020, 9:06pm

I would like to add multitenancy where each app in squidex is a tenant and the url will be use to differentiate the current tenant.

Sebastian · February 19, 2020, 7:00am

RIght now it is not possible but if you want to help, I would migrate it to .NET Core 3.1. Some classes like UserManager have to be registered with a scoped lifetime anyway and then you could write a factory that is registered as singleton and holds multiple client manager instances.

Eddyjl · February 19, 2020, 6:46pm

Are you able to provide a snippet of what to be modified?

thanks in advance.

Sebastian · February 19, 2020, 7:34pm

We have a few services likes this one, that get a squidex client manager:

github.com

Squidex/squidex-identity/blob/master/Squidex.Identity/Model/ClientStore.cs#L23


using IdentityServer4.Stores;
using Squidex.ClientLibrary;


namespace Squidex.Identity.Model
{
    public sealed class ClientStore : IClientStore
    {
        private readonly SquidexClient<ClientEntity, ClientData> apiClient;
        private readonly SquidexClientManager apiClientManager;


        public ClientStore(SquidexClientManager clientManager)
        {
            apiClient = clientManager.GetClient<ClientEntity, ClientData>("clients");
            apiClientManager = clientManager;
        }


        public async Task<Client> FindClientByIdAsync(string clientId)
        {
            var clients = await apiClient.GetAsync(filter: $"data/clientId/iv eq '{clientId}'", context: Context.Build());


            var client = clients.Items.FirstOrDefault();

Instead of injection the client manager we need an indirection, e.g.

class ClientManagerProvider {
   private IHttpContextAccessor  httpContextAccesor;
   private ConcurrentDictionary<string, SquidexClientManager> clientManagerPerDomain;
   private Dictionary<string, SquidexOptions> optionsPerDomain;

   public SquidexClientManager GetClientManager()
   {
        var host = httpContextAccessor.HttpContext.Request.Host;
   
        if (!optionsPerDomain.TryGetValue(host, out var options))
        { 
             throw new InvalidOperationException("Invalid host.");
        }

        return clientManagerPerDomain.GetOrAdd(host, x => new SquidexClientManager(options));
   }
}

Then you can either inject this provider to the services and create the clients on the fly (they are lightweight)

OR

When the services are registered as a scope we can just replace this line with something like

services.AddSingleton<ClientManagerProvider>();
services.AddSingleton<SquidexClientManager>(c => c.GetRequiredService<ClientManagerProvider>().GetClientManager());

Sebastian · February 19, 2020, 7:36pm

When looking how the services are registered, the second approach should work fine:

e.g.

github.com

IdentityServer/IdentityServer4/blob/41f83cd7bf22c87fd4be98df9b8eaefafd80dbc2/src/IdentityServer4/src/Configuration/DependencyInjection/BuilderExtensions/Additional.cs#L93




    return builder;
}


/// <summary>
/// Adds a client store.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="builder">The builder.</param>
/// <returns></returns>
public static IIdentityServerBuilder AddClientStore<T>(this IIdentityServerBuilder builder)
   where T : class, IClientStore
{
    builder.Services.TryAddTransient(typeof(T));
    builder.Services.AddTransient<IClientStore, ValidatingClientStore<T>>();


    return builder;
}


/// <summary>
/// Adds a resource store.

OR

github.com

dotnet/aspnetcore/blob/af9f99299cd4a059cf30483d4f7f551ff38c5a28/src/Identity/Extensions.Core/src/IdentityBuilder.cs#L215


/// Adds a <see cref="IRoleStore{TRole}"/> for the <see cref="RoleType"/>.
/// </summary>
/// <typeparam name="TStore">The role store.</typeparam>
/// <returns>The current <see cref="IdentityBuilder"/> instance.</returns>
public virtual IdentityBuilder AddRoleStore<TStore>() where TStore : class
{
    if (RoleType == null)
    {
        throw new InvalidOperationException(Resources.NoRoleType);
    }
    return AddScoped(typeof(IRoleStore<>).MakeGenericType(RoleType), typeof(TStore));
}


/// <summary>
/// Adds a <see cref="RoleManager{TRole}"/> for the <see cref="RoleType"/>.
/// </summary>
/// <typeparam name="TRoleManager">The type of the role manager to add.</typeparam>
/// <returns>The current <see cref="IdentityBuilder"/> instance.</returns>
public virtual IdentityBuilder AddRoleManager<TRoleManager>() where TRoleManager : class
{
    if (RoleType == null)

Sebastian · February 20, 2020, 6:16pm

I have started to convert it. It is pushed, but really untested so far.