La bonne idée de QtScript

Bonjour ,

Je sais que QtScript est mon idée, je sais que c'est pas bien de dire soi-même que c'est une bonne idée, mais bon, là ça m'a bien sauvé .

Je construit actuellement le démon de construction automatique des paquets Logram. Tout se passe bien, les paquets sont actuellement téléchargés et dépaquetés.

Il faut maintenant installer les dépendances de construction, et j'ai besoin pour cela d'un pesage spécial des paquets.

En effet, il est hors de question qu'un paquet de stable soit compilé avec un paquet d'experimental, il risque de ne pas marcher avec sa version dans stable.

Bref, il faut filtrer les distributions, ce qui se fait facilement en générant un sources.list spécial pour le paquet .

Ensuite, il y a l'étape pesage des branches. Le but est de sélectionner les paquets les plus récents, pour éviter qu'un paquet d'expérimental soit compilé avec un paquet de old, et qu'il ne fonctionne pas avec la nouvelle version. On ne peut pas utiliser uniquement experimental, car il se peut qu'une dépendance d'un paquet dans experimental soit dans testing, un de testing dans stable, etc.

La solution retenue est une liste des distributions compatibles avec une autre, sauvegardée dans un fichier :

1
2
3
4
5

experimental=experimental testing core extra contrib unfree
testing=testing core extra contrib
core=core
extra=extra core
unfree=unfree core extra

Ainsi, on peut construire un sources.list ne contenant que ces distributions, ce qui évite tout problème.

Puis vient le pesage, et c'est là que le QtScript aide vraiment. Si j'avais codé en dur les règles de pesage, ça aurait été impossible (on aurait juste eu la règle limitant le nombre de téléchargements, ou autre, qui ne s'applique pas si on construit sur le serveur en local).

Il me suffit simplement de remplacer le script weight.qs par celui-ci :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

function weight(list)
{
    var w;
    w = 0;

    regex = /\\D+/g
    regex.compile(regex)

    for (var i=0; i<list.length; i++)
    {
        pkg = list[i];

        // Retirer le poids de la version (plus c'est récent, mieux c'est)
        str = pkg.version
        parts = str.split(regex)
        var summ = 0;

        for (var i=0; i<parts.length; i++)
        {
            part = parts[i];

            part *= 100;

            for (var j=0; j<i; j++)
            {
                part /= 100;
            }

            summ += part
        }

        w -= summ;
    }

    return w;
}

Le fonctionnement est assez simple : plus un paquet a une version élevée, plus son score est élevé. Une version du type "1.2rev5ubuntu3" aura un poids de 102.0503. Le poids des paquets permet de calculer le poids de la branche.

Pas besoin de gérer des trucs complexes, on ne gère que des dépendances (pas de conflits), et c'est une installation sur du propre. Il n'y a donc pas de mise à jour, pas de suppression, uniquement des installation.

Les dépendances sont également fixées, ce qui fait que chaque branche aura (en simplifiant un peu) le même nombre de paquets que les autres.

Il ne reste plus que les versions qui jouent, donc tout se passe bien. En réalité, le paquet dans core a peut-être plus de dépendances que celui dans testing, donc ça lui ajoutera du poids, et il y a un risque que le pesage soit faux. Il faut encore que je trouve comment corriger ce problème (peut-être en n'additionnant pas les poids des paquets, mais en calculant leur moyenne, mais là, ça peut aussi être faussé, mais moins facilement (genre, dépendre d'un paquet en plus en version 2 ne faussera pas, mais s'il est en version 40, peut-être)).

Je vous donnerai des nouvelles bientôt .