Ces derniers jours j'ai été confronté à une problématique très intéressante; j'aimerais la partager avec vous aujourd'hui et vous soumettre la solution que j'ai imaginé pour y répondre.
Mon client souhaitait restreindre l'accès à son site/application intranet aux seuls membres d'un groupe Windows prédéfini.
Le hic est que le site fonctionne avec des rôles définis en base de données, laissant ainsi libre champs aux admins de l'appli d'attribuer et révoquer des droits aux autres utilisateurs. Évidement, il était hors de question de devoir passer par l'IT pour changer les droits des utilisateurs à l'avenir.
Si l'on transpose la demande en termes techniques, on a besoin du
WindowsTokenRoleProvider pour autoriser l'accès au site et pour tout le reste il faut se reposer sur un
SqlRoleProvider.
Comme vous le savez, ce genre de configuration n'est pas prise en charge par le modèle de provider tel que nous le connaissons jusqu'à présent.
En cherchant sur la toile si ce genre de situation à déjà été traitée (ne réinventons pas la roue carrée), vous tomberez très certainement sur
un article de Scott Guthrie qui traite d'un problème très similaire. Dans l'article
l'homme à la chemise rouge nous montre comment, sans code, utiliser les rôles issus de la base de données et n'autoriser l'accès au site
qu'aux utilisateurs identifiés. Et c'est bien sur ce dernier point que nos problématiques diffèrent car dans mon cas, il ne suffit pas d'être identifié sur le domaine, mais il faut aussi faire partie d'un groupe d'utilisateurs.
J'ai donc remonté mes manches, et quitte à écrire du code j'ai tenté de trouver une solution générique permettant de combiner des RoleProvider.
Commençons par définir un RoleProviderDecorator qui comme son nom l'indique suit le pattern
Decorator.
public class RoleProviderDecorator<TSurrogateRoleProvider> : RoleProvider
where TSurrogateRoleProvider : RoleProvider, new()
{
protected TSurrogateRoleProvider _surrogate;
public override void Initialize(string name, NameValueCollection config)
{
if (config == null)
throw new ArgumentNullException("config");
base.Initialize(name, config);
_surrogate = new TSurrogateRoleProvider();
InitializeInnerProvider(_surrogate, name, config);
}
protected virtual void InitializeInnerProvider(RoleProvider innerProvider, string name, NameValueCollection config)
{
innerProvider.Initialize(name, config);
}
public override bool IsUserInRole(string username, string roleName)
{
return _surrogate.IsUserInRole(username, roleName);
}
public override string[] GetRolesForUser(string username)
{
return _surrogate.GetRolesForUser(username).ToArray();
}
public override void CreateRole(string roleName)
{
_surrogate.CreateRole(roleName);
}
public override bool DeleteRole(string roleName, bool throwOnPopulatedRole)
{
return _surrogate.DeleteRole(roleName, throwOnPopulatedRole);
}
public override bool RoleExists(string roleName)
{
return _surrogate.RoleExists(roleName);
}
public override void AddUsersToRoles(string[] usernames, string[] roleNames)
{
_surrogate.AddUsersToRoles(usernames, roleNames);
}
public override void RemoveUsersFromRoles(string[] usernames, string[] roleNames)
{
_surrogate.RemoveUsersFromRoles(usernames, roleNames);
}
public override string[] GetUsersInRole(string roleName)
{
return _surrogate.GetUsersInRole(roleName).ToArray();
}
public override string[] GetAllRoles()
{
return _surrogate.GetAllRoles().ToArray();
}
public override string[] FindUsersInRole(string roleName, string usernameToMatch)
{
return
_surrogate.FindUsersInRole(roleName, usernameToMatch).ToArray();
}
public override string ApplicationName
{
get { return _surrogate.ApplicationName; }
set { _surrogate.ApplicationName = value; }
}
}
L'idée du décorateur, vous l'aurez compris, est de déléguer l’exécution des méthodes au vrai RoleProvider passé sous forme de
Generic.
Maintenant définissons un RoleProvider qui se charge d'utiliser de manière sous-jacente deux RoleProvider :
public abstract class UnionRoleProvider<TPrimaryRoleProvider, TSecondaryRoleProvider> : RoleProviderDecorator<TPrimaryRoleProvider>
where TPrimaryRoleProvider : RoleProvider, new()
where TSecondaryRoleProvider : RoleProvider, new()
{
private TSecondaryRoleProvider _secondSurrogate;
public override void Initialize(string name, NameValueCollection config)
{
if (config == null)
throw new ArgumentNullException("config");
base.Initialize(name, config);
_secondSurrogate = new TSecondaryRoleProvider();
InitializeInnerProvider(_secondSurrogate, name, config);
}
public override bool IsUserInRole(string username, string roleName)
{
return _surrogate.IsUserInRole(username, roleName) || _secondSurrogate.IsUserInRole(username, roleName);
}
public override string[] GetRolesForUser(string username)
{
return _surrogate.GetRolesForUser(username).Union(_secondSurrogate.GetRolesForUser(username)).ToArray();
}
public override void CreateRole(string roleName)
{
_surrogate.CreateRole(roleName);
_secondSurrogate.CreateRole(roleName);
}
public override bool DeleteRole(string roleName, bool throwOnPopulatedRole)
{
return _surrogate.DeleteRole(roleName, throwOnPopulatedRole) && _surrogate.DeleteRole(roleName, throwOnPopulatedRole);
}
public override bool RoleExists(string roleName)
{
return _surrogate.RoleExists(roleName) || _secondSurrogate.RoleExists(roleName);
}
public override void AddUsersToRoles(string[] usernames, string[] roleNames)
{
_surrogate.AddUsersToRoles(usernames, roleNames);
_secondSurrogate.AddUsersToRoles(usernames, roleNames);
}
public override void RemoveUsersFromRoles(string[] usernames, string[] roleNames)
{
_surrogate.RemoveUsersFromRoles(usernames, roleNames);
_secondSurrogate.RemoveUsersFromRoles(usernames, roleNames);
}
public override string[] GetUsersInRole(string roleName)
{
return _surrogate.GetUsersInRole(roleName).Union(_secondSurrogate.GetUsersInRole(roleName)).ToArray();
}
public override string[] GetAllRoles()
{
return _surrogate.GetAllRoles().Union(_secondSurrogate.GetAllRoles()).ToArray();
}
public override string[] FindUsersInRole(string roleName, string usernameToMatch)
{
return
_surrogate.FindUsersInRole(roleName, usernameToMatch)
.Union(_secondSurrogate.FindUsersInRole(roleName, usernameToMatch))
.ToArray();
}
}
Dans mon cas, seul un des deux RoleProvider doit pouvoir écrire dans son médium de stockage.
L'autre doit être en lecture seule. Pour ce faire, j'introduis un ReadOnlyRoleProvider :
public class ReadOnlyRoleProvider<TSurrogateRoleProvider> : RoleProviderDecorator<TSurrogateRoleProvider>
where TSurrogateRoleProvider : RoleProvider, new()
{
public override void CreateRole(string roleName){}
public override bool DeleteRole(string roleName, bool throwOnPopulatedRole)
{
return true;
}
public override void AddUsersToRoles(string[] usernames, string[] roleNames){}
public override void RemoveUsersFromRoles(string[] usernames, string[] roleNames){}
Ça y est on a fait 90% du boulot.
Dans le fichier web.config on veut écrire ceci :
<roleManager enabled="true" defaultProvider="MyRoleProvider">
<providers>
<clear/>
<add name="MyRoleProvider " type="Providers.MyRoleProvider " connectionStringName="cnx" applicationName="MyApp" />
</providers>
</roleManager>
Étant donné que l'on ne peut pas utiliser de classe générique dans la config, on va simplement en spécialiser une :
public class MyRoleProvider : UnionRoleProvider<SqlRoleProvider, SilentWindowsTokenRoleProvider<WindowsTokenRoleProvider>>
{
protected override void InitializeInnerProvider(RoleProvider innerProvider, string name, NameValueCollection config)
{
NameValueCollection cfg = config;
if (innerProvider is ReadOnlyRoleProvider<WindowsTokenRoleProvider>)
{
cfg = new NameValueCollection(config);
cfg.Remove("connectionStringName");
}
base.InitializeInnerProvider(innerProvider, name, cfg);
}
}
Ouf, 99% du boulot. Vous pouvez maintenant exécuter et ça va fonctionner... jusqu'à ce que vous utilisiez une des méthodes suivantes :
- GetUsersInRole
- GetAllRoles
- FindUsersInRole
Tout simplement parce que le
WindowsTokenRoleProvider ne supporte pas ces opérations.
Ok, voici le tout dernier % à réaliser :
public class SilentWindowsTokenRoleProvider<TSurrogateRoleProvider> : ReadOnlyRoleProvider<TSurrogateRoleProvider>
where TSurrogateRoleProvider : RoleProvider, new()
{
public override string[] GetUsersInRole(string roleName)
{
return new string[]{};
}
public override string[] GetAllRoles()
{
return new string[]{};
}
public override string[] FindUsersInRole(string roleName, string usernameToMatch)
{
return new string[]{};
}
}
Voila 100% de la solution; beaucoup de code aujourd'hui, j'espère que ça ne vous a pas trop démotivé.
Si vous avez une solution autre, ou contestez mon approche n'hésitez pas à laisser un commentaire.
