Propositions de solutions fonctionnelles
(les solutions techniques seront discutées ultérieurement)
Proposition 1 (restreinte aux droits d'utilisation des actions)
Voir
ActionEtDroitDUtilisation.
Proposition 2 (restreinte aux problèmes de gestion des pages)
[...] on peut très bien imaginer que la gestion de cette administration soit, par défaut, déleguée a chaque utilisateur, pour, par exemple, laisser le choix au créateur d'une page de modifier ses ACL pour qu'elle soit accessible en lecture, ecriture, commentaire aux utilisateurs identifiés ou aux anonymes. On peut imaginer que l'administrateur du site definisse un comportement par défaut lors de l'initialisation d'un Wakka, chaque utilisateur pouvant ensuite modifier ce comportement, c'est ce que je préfere et c'est ce qu'il y a en place dans Wakka actuellement, mais on peut laisser le choix également à l'administrateur d'imposer ce comportement par défaut (comme les "forced preferences" de
phpgroupware).
--
DavidDelon
[...] Par exemple j'ai fais une action qui permet de créer des utilisateurs mais je l'ai restreinte à mon utilisateur que j'ai nommé
WikiAdmin.... il faudrait que je définisse des privilèges pour les utilisateurs...). [...] en fait il faut que j'y travaille d'avantage pour que ça soit "généralisé" et pas seulement pour mon site.
--
PatrickPaul
Proposition 3 (restreinte aux problèmes de gestion des pages)
Je trouve que vous avez déjà fait du bon travail concernant la gestion des acls ! Pour ma part je l'ai un peu modifiée pour y inclure la notion d'administrateurs fonctionnels (indiqués par le symbole '@' dans les acls) qui n'ont pas tous les droits comme on pourrait le penser (ils subissent les droits normaux des utilisateurs), mais ils ont toujours le droit de modifier les acls des pages. J'ai aussi modifié le fait que le propriétaire d'un document n'a pas systématiquement les droits d'écriture sur une page (un administrateur peut les lui retirer tout en laissant le propriétaire de la page intact), mais il a toujours le droit de modifier les acls. Je suis en train de réfléchir au fait d'ajouter un droit acl de changer les acls, qui serait réservé aux administrateurs fonctionnels exclusivement. Ce droit d'acl autoriserait le propriétaire d'une page à changer ses acl mais là aussi un administrateur fonctionnel pourrait lui retirer ce droit (ou on pourrait même ne pas le donner par défaut).
--
ProgFou
- Ton idée à l'air très intéressante. Mais je peine à comprendre : si les admins fonctionnels ont le droit de modifier les acls, ils ont donc tous les droits non ? A quoi sert de les désigner d'un signe "@" puisqu'ils ont les droits de modifier les acls ? Peux-tu reformuler (avec des exemples ?) ? -- CharlesNepote
- Je pars du principe que les acls sont là pour être appliquées systématiquement ; ça simplifie beaucoup la sécurité, en la clarifiant : les droits sont ceux affichés et rien d'autre (pas de droit implicite, chez moi j'ai commenté le test UserIsOwner? par exemple) ! Ensuite, le seul moyen de passer outre une interdiction serait de pouvoir changer l'acl concernée.
- Actuellement on a trois type de droits :
- qui peut lire la page (tout le monde par défaut) ;
- qui peut écrire la page (tout le monde par défaut ; chez moi c'est un cas particulier : seulement les inscrits) ;
- qui peut commenter la page (tout le monde par défaut) ;
- Ce qui peut se généraliser simplement en "qui peut faire quoi sur quoi".
- Au niveau implémentation, vous avez déjà bien fait les choses avec une fonction HasAccess($privilege, $tag, $user), qui est assez générique, et quelques valeurs de privilèges : read, write et comment. Il suffirait de généraliser encore son utilisation en ajoutant un privilège supplémentaire : changeacl = qui peut accéder aux acls. Ce privilège conditionnerait l'accès au handler acls et sa valeur par défaut serait : le propriétaire (je propose le signe =) et les administrateurs fonctionnels (signe @). Ce privilège ne serait modifiable que par les administrateurs fonctionnels et ce champ n'apparaîtrait donc que dans ce contexte. Si les administrateurs fonctionnels retiraient leur accès du champ changeacl, seul l'administrateur technique (le "root" du WikiNi) pourrait rétablir la situation en intervenant directement sur la base. On pourrait généraliser encore plus, en faisant une gestion complètement paramétrable des accès, champ par champ, mais ça devra attendre l'arrivée du WikiniSemantique ! :)
- Par ailleurs, je pense aussi qu'il serait mieux d'utiliser des mots sémantiques plutôt que des signes dans la désignation des accès. Dans la spécification des acls je suggère de remplacer (ou plutôt ajouter, dans un premier temps) les signes de la manière suivante : un + par +users, un @ par +admin, un * par +all, et un = par +owner. Ça devrait aussi faciliter l'implémentation des groupes ! Et au sujet des groupes justement, vu que j'en aurai probablement besoin aussi, je propose d'ajouter une colonne group à la table wikini_users ; si quelqu'un appartient à plusieurs groupes, ceux-ci pourraient être séparés par des \n. Ce serait plus efficace que de faire une table des groupes, mais ça pourrait aussi rendre la recherche des membres d'un groupe plus difficile ; à voir ...
- J'aurai aussi besoin de lier tout ça à un LDAP ... Mais c'est pas urgent et je reviendrai "à la charge" à ce moment là ! ;-)
- -- ProgFou, avec tout plein de besoins ! ;-)
Comment sauvegarder ces données administratives ?
Actuellement ces données "administratives" sont stockées de plusieurs manières :
- en base de données pour la gestion des droits d'accès
- dans le fichiers wakka.config.php pour certains paramètres fonctionnels
- dans les fichiers CSS pour la présentation
On pourrait conserver ces différents modes de stockage mais cette solution comporte de nombreux inconvénients :
- obligation de maintenir plusieurs méthodes de stockage et modification
- pour sauvegarder un site, il faut sauvegarder les différentes formes de stockage séparément
Ne peut-on imaginer de sauvegarder au maximum ces informations fonctionnelles en base de données ? Quitte à écrire une fonction générique générant des fichiers aux bons endroits si nécessaire. L'avantage c'est qu'une simple sauvegarde de la base permet de sauvegarder l'intégralité d'un site, y compris les données administratives. On pourrait à ce titre adopter en partie les propositions que j'ai fait à propos d'un
WikiSemantique? : il s'agit de créer en base une table, et une seule, où nous stockons plusieurs paramètres différents selon la logique des triplets (une partie du code est déjà prêt dans
WikiniSemantiqueSolutionsTechniques).
Par exemple :
- <l'ensemble des pages> <a pour purge> <24 jours>
- <l'ensemble des pages> <a pour droit d'écriture par défaut> <*>
- <l'ensemble des pages> <a pour mots clefs> <*>
- etc.
Cela permet :
- aux développeurs de WikiNi d'envisager sereinement d'autres paramètres fonctionnels sans modifier le modèle de données
- à d'autres développeurs de personnaliser WikiNi sans perdre la compatibilité avec WikiNi
--
CharlesNepote
Solutions techniques
I. Solution provisoire, simple et efficace via le fichier de configuration
Une première solution peut consister à ajouter des variables de configuration dans wakka.config.php.
On peut imaginer deux types de variables supplémentaires :
La première indiquant le nom des administrateurs.
La seconde indiquant le nom des actions qui sont réservées aux seuls admins.
On ajoute un test dans la function "Action" du noyau et le tour est joué.
Pour le test on aurait quelque chose du genre :
<?php
$array_reserved_actions = explode(";", $this->config['reserved_2_admin']);
foreach ($array_reserved_actions as $value)
{
if ($this->action = $value)
{
$reserved_action = "1";
break;
}
}
$array_admins = explode(";", $this->config['wiki_admin']);
foreach ($array_admins as $value)
{
if ($this->user = $value)
{
$admin_right = "1";
break;
}
}
?>
Je pense qu'on peut rejeter définitivement ce type de solution car trop binaire : il n'est pas possible de déléguer certaines fonctions d'administration à d'autres, c'est tout ou rien. --
CharlesNepote
II. Solution provisoire, simple et efficace via le fichier de configuration
On peut imaginer un solution plus riche que la précédente du type :
- "DavidDelon" => "usersettings;rss;protection",
- "CharlesNepote" => "usersettings;rss",
- "reserved_2_admin" => "usersettings;rss;protection",
- Ou plutôt : "special_accesses" => Array ("DavidDelon" => "usersettings;rss;protection", "CharlesNepote" => "usersettings;rss", "reserved_2_admin" => "usersettings;rss;protection"), -- ProgFou
- Ça simplifie le traitement mais ça complique l'écriture du fichier wakka.config.php... je pense que des non connaisseurs de PHP risque d'avoir des problèmes avec cette notation alors que le fichier tel qu'il est actuellement a le mérite d'être simple à écrire. Je ne suis donc pas très favorable. L'idéal serait d'enregistrer tout ça en base... -- CharlesNepote
- Ce n'est pas tant une simplification de traitement - tout de même nécessaire si on ne faut pas avoir ensuite une énumération des intitulés des comptes avec droits spéciaux - qu'une formalisation des données. Mais je suis tout à fait d'accord sur le fait qu'un maximum de choses devraient être en base, on pourrait même en faire une page du Wiki (sur le ConceptToutEstPage) avec une ligne par NomWiki DroitsWiki. -- ProgFou
III. Solution provisoire, simple et efficace via le fichier de configuration
Similaire à la précédente :
- on modifie l'action GetConfigValue? pour s'adapter à la lecture de la variable de configuration fonctionnelle (soit dans wakka.config.php comme actuellement ; soit en base comme dans le futur)
- on créée une méthode permettant de tester un droit : IsAllowedFor? prenant en paramètre l'action et l'acteur (actuellement l'utilisateur mais éventuellement le groupe dans le futur)
- pour le moment les droits sont stockés dans le fichier de configuration mais peuvent être ensuite stocké ailleurs (seul les méthodes IsAllowedFor? et GetConfigValue? seront à réécrire)
- cette méthode est utilisée :
- soit dans le code de l'action (avantage : on peut écrire des actions protégées par défaut ; inconvénient : redondance)
- soit dans le code d'appel des actions (avantage : pas de redondance de code, simplicité pour le développeur ; inconvénient : par défaut toutes les actions sont ouvertes ?)
Note que je ne sais pas où mettre : il devrait y avoir deux types d'action
- les actions qui sont par défaut des actions auxquelles aucun utilisateur n'a accès sauf s'il est déclaré explicitement comme ayant droit d'accès
- les actions qui sont par défaut des actions auxquelles tous les utilisateurs ont accès sauf les utilisateurs déclarés explicitement comme n'ayant pas droit à ces actions
Une solution peut consister à mettre par défaut toutes les actions dans le premier groupe, chaque action "publique" étant explicitement configurée comme étant accessible à tous. Toutes les actions sensibles étant sans configuration, donc par défaut inacessibles, sauf l'action permettant de configurer ces droits, seule accessible l'administrateur créé à l'installaion.
Me paraît plus simple que la précédente :
- on a le minimum de ligne pour protéger l'utilisation d'une action
- on peut immédiatement lire qui a accès à telle action
- on modifie très peu le code de WikiNi
- on conserve la compatibilité ascendante (méthode GetConfigValue?)
- le test se fait dans l'action et ne perturbe donc pas le reste de WikiNi
- Ce qui donnera à peu près : if ($this->GetConfigValue("acl_action_usersettings") == $this->GetUser ()) { //traitements }
Je pense la mettre en oeuvre dans l'action d'annulation de vandalisme que je prépare.
--
CharlesNepote
J'aimerai bien avoir l'avis de quelques autres membres sur cette solution (les anciens comme les nouveaux). --
CharlesNepote
- L'utilisation de variables dans le fichier de configuration limite dans le futur la possibilité de pouvoir gérer cela à travers une interface. On peut très bien choisir cette solution là au départ mais je pense que le test doit être fait dans une méthode de l'objet wiki. Cela permettra à l'avenir de pouvoir stocker les variables dans la base de données si besoin est, sans devoir modifier les actions (il suffit de modifier la méthode et l'action n'y voit que du feu ;o). En ce qui concerne le préfixe acl_action_ il me va bien. -- OlivierB
- Oui, c'est une très bonne remarque car on devrait distinguer :
- les variables de configuration "technique", qui ne peuvent pas être stockées en base : typiquement les informations concernant la base SQL, l'adresse du site, etc. Je pense qu'on a pas 36 solutions et qu'on devra les laisser dans un fichier de configuration ;
- les variables de configuration "fonctionnelle" qui peuvent être stockées à différents endroits (fichier ou base), de différentes manières
- Ces dernières pourraient en effet faire l'objet d'une méthode particulière : par exemple GetFunctionnalConfigValue ; si, à terme, comme tu le proposes, on devait déplacer ces paramètres en base, il suffirait de réécrire la méthode. -- CharlesNepote
- Après quelques discussions avec LordFarquaad, il semble finalement que cela ne soit pas utile :
- parce qu'on perdrait la compatibilité ascendante
- parce qu'il est possible de gérer les problèmes évoqués au sein même de la méthode GetConfigValue. -- CharlesNepote
Ok.
[à revoir]
1. Je vais également passer la nouvelle méthode
IsAllowedFor ci-dessous
2. Les actions soumises à droits feront donc l'objet de deux étapes :
- dans le fichier de configuration, pour le moment, "acl_action_killzemol" => "CharlesNepote",
- dans l'action : if ($this->IsAllowedFor("acl_action_killzemol", $this->GetUser ()) { /* traitements */ }
if ($this->IsAllowedFor($action, $this->GetUser)) { /* traitements */ }
On aurrait donc [code non testé] :
<?php
// Test if an action is allowed for an actor (for a user, and, in the future, a group or a robot)
function IsAllowedFor($action, $actor)
{
$allowedActors = $this->GetConfigValue($action);
$arrayActors = explode (";", $allowedActors);
$n = 0;
while ($arrayActors)
{
if ($arrayActors[$n] == $actor) return true;
$n++;
}
return false;
}
?>
AIntegrerAuCVS
Au pire, si l'on voit que ça pose problème, il sera toujours temps de virer ça : il y a peu d'impact sur
WikiNi actuellement.
[je pense prendre encore un petit délai de réflexion]
--
CharlesNepote
Autres outils d'administrations
Si jamais ça intéresse quelqu'un, j'ai rapidement mis en place quelques autres actions :
- Purger une page (effacement complet historique, etc.) (facile, un peu comme deleteorphanedpage) ;
- Envoyer un email à tous les membres du site (ou à une partie seulement) ;
- Exporter un .zip contenant l'ensemble des données de la base (pratique pour répliquer en local ou faire un backup) ;
-- Sergio
Une meilleure idée pour la modification des droits d'accès pourrais se présenter sous cette forme :
"restricted_actions"=>array(
- "rss"=>"User1?\nUser2",
- "usersettings"=>User1?\nUser2",
);
Il est vrai que la syntaxe correspond plus a du PHP mais a l'avantage de permettre une customisation complète des accès pour chaque action. --
MagicalTux