source: spip-zone/_outils_/smart_paquets/inc_empaqueteur.php @ 52990

Last change on this file since 52990 was 52990, checked in by eric@…, 8 years ago

Il faut trimer (ça c'est sur!) les éléments de archivelist afin d'éviter de récupérer des espaces dans les noms de zip et de logo !

File size: 20.6 KB
Line 
1<?php
2
3// -------------------------------------- APPEL PRINCIPAL ------------------------------------------
4
5// Fonction principale appelee par le script empaqueteur.php
6// Elle lance successivement:
7// 1. la creation des zips et de la base des logos
8// 2. le nettoyage des paquets obsoletes
9// 3. la creation du fichier xml des paquets
10// 4. la creation du fichier des traductions de Salvatore
11// 5. la creation d'un index des logos
12//
13// $url                 : url du repository des sources (ex: svn://zone.spip.org/spip-zone)
14// $dir_repo    : repertoire racine des sources extraits du repository (ex: spip-zone)
15// $dir_paq             : repertoire de depot des paquets crees (ex: paquets)
16// $src                 : nom du fichier listant les archives a creer (ex: archivelist.txt)
17// $dest                : nom sans extension du fichier xml recapitulant toutes les archives (ex: archives)
18// $dtd_prio    : DTD a utiliser en priorite (plugin ou paquet)
19// $nom_vcs             : gestionnaire de versions motorisant le repository concerne (ex: svn)
20// $mail_to             : destinataire des mails d'information
21// $mail_from   : emetteur des mails d'information
22//
23// return               : aucun
24function empaqueteur($url, $dir_repo, $dir_paq, $src, $dest, $dtd_prio, $nom_vcs, $mail_to, $mail_from) {
25        global $erreurs;
26        $dir_tmp = $dir_paq.'tmp/';
27        require('inc_outils.php');
28
29        // On charge les includes correspondant aux DTD utilisees
30        require('empaqueteur_plugin.php');
31        require('empaqueteur_paquet.php');
32
33        $erreurs = array();
34        $url = trim($url);
35        $dir_repo = rtrim($dir_repo ? $dir_repo : basename($url),'/') .'/';
36        $dir_paq = rtrim($dir_paq ? $dir_paq : '.','/') .'/';
37       
38        // 1. creation des zips et de la base des logos
39        list($depot, $zips, $logos) = empaqueteur_archives($url, $dir_repo, $dir_paq, $src, $nom_vcs, $dtd_prio);
40       
41        // 2. nettoyage des paquets et logos obsoletes
42        if (!$erreurs) {
43                $fichiers_a_conserver = array_keys($zips);
44                $fichiers_a_conserver = array_merge($fichiers_a_conserver, $logos);
45                // ne pas nettoyer le fichier archives.xml !
46                foreach(is_array($dest) ? $dest : array($dest) as $nom_dest)
47                        $fichiers_a_conserver[] = $nom_dest . '.xml';
48                // ne pas nettoyer le fichier traductions.txt !
49                $fichiers_a_conserver[] = 'traductions.txt';
50                // ne pas nettoyer l'index des logos logos.php !
51                $fichiers_a_conserver[] = 'logos.php';
52                nettoyer_vieux_fichiers($fichiers_a_conserver, $dir_paq . $dir_repo, $dir_tmp);
53        }
54        elseif ($mail_to) 
55                envoyer_mail($erreurs, $mail_to, $mail_from);
56
57       
58        // 3. la creation du fichier xml des paquets
59        // -- obtention des contenus du fichier xml des paquets et de celui des traductions Salvatore
60        list($archives, $salvatore) = empaqueteur_resultats($depot, $zips);
61        if ($archives)
62                empaqueteur_xml_archives($dest . '.xml', $archives, $dir_paq, $dir_repo);
63        else
64                echo_trace("Aucun Zip produit");
65
66        // 4. la creation du fichier des traductions de Salvatore
67        if ($salvatore)
68                empaqueteur_salvatore('traductions.txt', $salvatore, $dir_paq, $dir_repo);
69        else
70                echo_trace("Aucune traduction avec Salvatore");
71
72        // 5. la creation d'un index des logos
73        empaqueteur_index_logos('logos.php', $dir_paq, $dir_repo);
74}
75
76
77// ---------------------------------- CREATION DES ARCHIVES ----------------------------------------
78
79// Fonction de creation des zips et de la base des logos
80// Elle lance successivement:
81// 1. Creation des repertoires de travail et import initial (uniquement la premiere fois)
82// 2. Check-out ou update des sources a archiver
83// 3. Lecture de la liste des archives a creer
84// 4. Creation de la liste des archives requises
85//
86// $url                 : url du repository des sources (ex: svn://zone.spip.org/spip-zone)
87// $dir_repo    : repertoire racine des sources extraits du repository (ex: spip-zone)
88// $dir_paq             : repertoire de depot des paquets crees (ex: paquets)
89// $src                 : nom du fichier listant les archives a creer (ex: archivelist.txt)
90// $nom_vcs             : gestionnaire de versions motorisant le repository concerne (ex: svn)
91// $dtd_prio    : DTD a utiliser en priorite (plugin ou paquet)
92//
93// return               : tableau des infos du depot et des zips crees
94//                                      0 : tableau associatif (info -> valeur) de chaque info collectee sur le depot
95//                                      1 : tableau associatif (nom de l'archive -> liste des infos) des zips crees
96//                                      2 : chemin complet du logo
97function empaqueteur_archives($url, $dir_repo, $dir_paq, $src, $nom_vcs, $dtd_prio) {
98        // Definition des deux sous-repertoires temporaires et definitifs des paquets
99        $dir_tmp = $dir_paq.'tmp/';
100        $dir_paq .= $dir_repo;
101
102        // Test pour savoir si le gestionnaire de version est bien installe sur le serveur
103        if (!function_exists($vcs = 'vcs_exec_' . $nom_vcs)) {
104                echo_trace("VCS non disponible: '$nom_vcs'");
105                $vcs = 'explode'; // i.e. ne fait rien de ses arguments.
106        }
107
108        // 1. Creation des repertoires de travail et import initial
109        if (!file_exists($dir_repo)){
110                preparer_chemin(dirname(rtrim($dir_repo,'/')));
111                if ($url) $vcs("checkout", "$url $dir_repo");
112        }
113        if (!file_exists($dir_paq))
114                preparer_chemin($dir_paq);
115        if (!file_exists($dir_tmp))
116                preparer_chemin($dir_tmp);
117
118        // 2. Check-out ou update des sources a archiver
119        // Si le repo est en file:// on fait un svnsync dessus,
120        // le up est fait par un hook post-commit sur ce qui a change uniquement
121        // sauf une fois par jour
122        if (preg_match(',^file://,',$url)) {
123                $vcs("sync", $url);
124                if (_FORCE_UPDATE)
125                        $vcs("up",rtrim($dir_repo,'/'));
126        }
127        elseif ($url) {
128                $vcs("up", rtrim($dir_repo,'/'));
129        }
130
131        // 3. Lecture de la liste des archives a creer et des informations sur le depot
132        list($depot, $paquets) = lister_paquets($dir_repo . $src);
133
134        // 4. Creation de la liste des archives requises
135        $zips = array();
136        $logos = array();
137        foreach($paquets as $_paquet){
138                if ($_paquet['revision']=='HEAD' 
139                AND list($infos, $logo) = creer_paquet($_paquet, $dir_repo, $dir_paq, $dir_tmp, $vcs, $dtd_prio)) {
140                        $zips[$_paquet['nom'] .".zip"] = $infos;
141                        if ($logo) $logos[] = $logo;
142                        if (intval(_SLEEP_BETWEEN)) usleep(_SLEEP_BETWEEN);
143                }
144        }
145        echo_trace(count($zips) . " trouves");
146
147        return array($depot, $zips, $logos);
148}
149
150
151// Lister les paquets demandes dans le fichier des archives
152// et compiler les informations sur le depot
153//
154// $src                 : nom du fichier listant les archives a creer
155//
156// return               : tableau des infos du depot et des archives a creer
157//                                      0 : tableau associatif (info -> valeur) de chaque info collectee sur le depot
158//                                      1 : tableau associatif des archives a creer (source, nom, nom_dossier et revision)
159function lister_paquets($src) {
160
161        echo_trace("chargement de $src");
162        if (!$archivefile=file($src)){
163                echo_trace("Erreur : Impossible de lire $src");
164                return array();
165        }
166
167        $depot = array();
168        $paquets = array();
169        foreach($archivefile as $ligne=>$lignepaquet){
170                //on vire le retour ligne de la fin
171                $lignepaquet=rtrim($lignepaquet);
172                if (strlen($lignepaquet)) {
173                        if (substr($lignepaquet,0,1)!="#") {
174                                // C'est une ligne de definition d'un paquet :
175                                // - on separe les parametres
176                                // - et on fixe ceux manquants
177                                $a = explode(";",$lignepaquet);
178                                $b = preg_split("/:/",$a[0]);
179                                $source = trim($b[0]);
180                                $svn_version = empty($b[1]) ?'HEAD' : trim($b[1]);             
181                                $nom_paquet = empty($a[1]) ? basename($source) : trim($a[1]);
182                                $nom_dossier = empty($a[2]) ? $nom_paquet : trim($a[2]);
183                                // Ajout au tableau des paquets a construire
184                                $paquets[] = array('source'=>rtrim($source,'/'),
185                                                   'nom'=>$nom_paquet,
186                                                   'nom_dossier'=>$nom_dossier,
187                                                   'revision'=>$svn_version);
188                        }
189                        else if (preg_match('#@([^=\s]+)\s*=(.+)$#', substr($lignepaquet, 1), $matches)){
190                                // C'est une ligne d'information sur le depot
191                                // - on stocke le parametre trouve
192                                $depot[trim($matches[1])] = trim($matches[2]);
193                        }
194                }
195        }
196
197        echo_trace(count($depot)." informations de depot definies");
198        echo_trace(count($paquets)." paquets definis");
199        return array($depot, $paquets);
200}
201       
202
203// Fonction de creation d'un paquet soit :
204// - de l'archive des sources (zip actuellement)
205// - des informations completes sur le paquet (yc la liste des traductions)
206// - et de son logo eventuel
207//
208// $paquet              : tableau des infos sur l'archive a creer
209// $dir_repo    : repertoire racine des sources extraits du repository
210// $dir_paq             : repertoire de depot des paquets crees
211// $dir_tmp             : repertoire temporaire de depot des archives crees
212// $vcs                 : fonction d'interface du vcs utilise (ex: vcs_exec_svn)
213// $dtd_prio    : DTD a utiliser en priorite (plugin ou paquet)
214//
215// return               : tableau des infos
216//                  0 : paquet cree
217//                                              0 : taille du paquet
218//                                              1 : date du paquet
219//                                              2 : arborescence des sources du paquet (relatif a l'url des sources)
220//                                              3 : date du dernier commit
221//                                              4 : liste des traductions sous la forme de la balise XML <traductions>
222//                                              5 : contenu du fichier xml du plugin
223//                                              6 : balises nom, slogan et description en multi tirees des fichiers de langue
224//                                              7 : dtd utilisee
225//                  1 : logo cree (fichier)
226function creer_paquet($paquet, $dir_repo, $dir_paq, $dir_tmp, $vcs, $dtd_prio) {
227        // Verifier le repertoire source du paquet a creer
228        $dsource = $dir_repo. $paquet['source'];
229        if (!file_exists($dsource)){
230                echo_trace("Erreur : $dsource inexistant");
231                return false;
232        }
233       
234        // Creation de l'archive
235        // -- Ajouter le fichier svn.revision dans les fichiers de l'archive pour les besoins de SPIP
236        $rev = $dsource . "/svn.revision";
237        $vcs("info", "$dsource > $rev");
238        $info = renseigner_revision_paquet($rev);
239        // -- zipper les sources incluant le fichier svn.revision
240        $zip = $paquet['nom'] .".zip";
241        $zippath = $dir_paq.$zip;
242        if (!archiver($dsource, $zip, $zippath, $paquet['nom_dossier'], $info, $dir_tmp))
243                return false;
244        // -- Traiter le cas de SPIP :
245        //    copier le svn.revision de stable/spip.zip qui permet de connaitre la derniere version stable
246        if ($zip=="stable/spip.zip") {
247                // necessaire de remettre le fichier a la date actuelle
248                // car il a la date du dernier commit sur ce paquet
249                # touch($dsource."/svn.revision");
250                copie_update($rev, $dir_paq.dirname($zip)."/svn.revision");
251        }
252        // -- supprimer le fichier info revision cree ci-dessus
253        @unlink($rev);
254
255        // Determination de la dtd a utiliser
256        $dtd = '';
257        $f = $dsource . '/' . $dtd_prio . '.xml';
258        if (file_exists($f))
259                $dtd = $dtd_prio;
260        else {
261                $autre_dtd = ($dtd_prio == 'plugin') ? 'paquet' : 'plugin';
262                $f = $dsource . '/' . $autre_dtd . '.xml';
263                if (file_exists($f))
264                        $dtd = $autre_dtd;
265                else {
266                        // Paquet sans xml correspondant a une contribution quelconque
267                        echo_trace("(info) Paquet $zip sans fichier XML");
268                        $desc = '';
269                } 
270        }
271       
272        $traductions = '';
273        $logo = '';
274        $multis = '';
275        if ($dtd) {
276                // Recuperer le xml qui decrit le plugin et suppression de l'entete XML si elle existe
277                $re = ",<"."\?xml[^>]*\?".">,Uims";
278                $desc = trim(preg_replace($re, '', file_get_contents($f)));
279
280                // Construire la liste des traductions du plugin
281                $traductions = compiler_traductions($dsource);
282
283                // Contruire les balises multi du nom, slogan et description qui ne sont plus dans le paquet
284                $f = 'empaqueteur_' . $dtd . '_multi';
285                $multis = !function_exists($f) ? '' : $f($dsource);
286
287                // Creer le logo du paquet
288                $f = 'empaqueteur_' . $dtd . '_logo';
289                $f = !function_exists($f) ? '' : $f($desc, $dsource);
290                if ($f AND file_exists($f) AND preg_match('/[.][^.]*$/', $f, $r)) {
291                        $logo = $paquet['nom'] . $r[0];
292                        $d = $dir_paq . $logo;
293                        copy($f, $d);
294                }
295        }
296       
297        return array(
298                        array(
299                                filesize($zippath),
300                                filemtime($zippath),
301                                $paquet['source'],
302                                $info[1],
303                                $traductions,
304                                $desc,
305                                $multis,
306                                $dtd),
307                        $logo);
308}
309
310
311// Fonction de creation d'une archive des sources contenu dans une arborescence donnee.
312// Aujourd'hui l'archive est toujours un zip
313//
314// $source              : emplacement des sources a archiver
315// $zip                 : nom de l'archive a creer
316// $zippath             : chemin complet de l'archive a creer
317// $nom_dossier : arborescence dans le zip qui sera cree lors du dezippage
318// $rev                 : tableau des informations sur le dernier commit (revision, date)
319// $dir_tmp             : repertoire temporaire de depot des archives creees
320//
321// return               : true/false
322function archiver($source, $zip, $zippath, $nom_dossier, $rev, $dir_tmp){
323        $zipfile = basename($zip);
324        list($revision, $date_commit) = $rev;
325        $date_paquet = file_exists($zippath) ? filemtime($zippath) : 0;
326        // tester si le paquet est a jour
327        if (strtotime($date_commit) <= $date_paquet AND !_FORCE_UPDATE) {
328                echo_trace("$zip OK : du ".date('Y-m-d H:i:s',$date_paquet)." / dernier commit du $date_commit");
329                return true;
330        }
331        else {
332                echo_trace("$zip OLD : du ".date('Y-m-d H:i:s',$date_paquet)." / dernier commit du $date_commit");
333                $tmp = $dir_tmp.$nom_dossier;
334                preparer_chemin($tmp);
335                if (!rename($source,$tmp)) {
336                        echo_trace("Erreur : $source --> $tmp");
337                        return false;
338                } else {
339                        $d = getcwd();
340                        chdir($dir_tmp);
341                        $base_dir = reset(explode('/',$nom_dossier));
342                        // zipper en prenant la date du fichier le plus recent
343                        // comme date du paquet
344                        exec_trace("zip -roq $zipfile $base_dir -x \*/.svn\*");
345                        chdir($d);
346
347                        $date_paquet = filemtime($dir_tmp.$zipfile);
348                        // cas ou le dernier commit consiste en la suppression de fichiers
349                        // du coup le zip est plus ancien que le dernier commit
350                        // on corrige manuellement
351                        if ($date_paquet<strtotime($date_commit)) {
352                                touch($dir_tmp.$zipfile,strtotime($date_commit)+1);
353                        }
354                        rename($tmp,$source);
355                }
356                supprimer_chemin($dir_tmp,$nom_dossier);
357                copie_update($dir_tmp.$zipfile,$zippath);
358                return true;
359        }
360}
361
362
363// Fonction de compilation de la liste des traductions d'un plugin sous forme d'une suite
364// de balises <traduction>
365// On considere que les fichiers de langue ou les rapports de salvatore sont toujours dans
366// le sous-repertoire lang/
367//
368// $source              : emplacement des sources du plugin
369//
370// return               : chaine composee des balises <traduction>
371function compiler_traductions($source){
372
373        // On charge une fois la liste des codes de langues
374        if (empty($GLOBALS['codes_langues']));
375                include('inc_langues.php');
376
377        $traductions = '';
378
379        // Determination des modules sous salvatore : on cherche les rapports xml
380        $modules_salvatore = array();
381        if ($rapports = glob($source . '/lang/*.xml')) {
382                foreach ($rapports as $_rapport) {
383                        $modules_salvatore[] = basename($_rapport, '.xml');
384                        $contenu = file_get_contents($_rapport);
385                        $traductions .= $contenu;
386                }
387        }
388
389        // Determination des modules non traduits par salvatore
390        // Cette recherche n'est pas totalement deterministe car on est oblige de considerer
391        // qu'il existe toujours un fichier module_fr.php pour identifier le nom du module
392        if ($fichiers_fr = glob($source . '/lang/*_fr.php')) {
393                foreach ($fichiers_fr as $_fichier_fr) {
394                        $nom_fichier = basename($_fichier_fr, '.php');
395                        // On exclut les fichiers de traduction du paquet.xml
396                        if (strpos($nom_fichier, 'paquet-') === false ) {
397                                $module = substr($nom_fichier, 0, strlen($nom_fichier)-3);
398                                // Si ce module n'a pas ete traite dans un rapport Salvatore on cherche toutes
399                                // ses traductions via les fichiers de langue.
400                                if (!in_array($module, $modules_salvatore) 
401                                AND ($fichiers_langue = glob($source . "/lang/$module_*.php"))) {
402                                        $liste_langues = '';
403                                        foreach ($fichiers_langue as $_fichier_langue) {
404                                                $nom_fichier = basename($_fichier_langue, '.php');
405                                                $langue = substr($nom_fichier, strlen($module) + 1 - strlen($nom_fichier));
406                                                // Si la langue est reconnue, on l'ajoute a la liste des traductions
407                                                // Comme on ne connait pas les traducteurs, la balise est donc vide
408                                                if (isset($GLOBALS['codes_langues'][$langue]) AND $langue != 'fr')
409                                                        $liste_langues .= "\t" . '<langue code="' . $langue . '" />' . "\n";
410                                        }
411                                        // Le gestionnaire n'est pas precise et la langue de reference est toujours le fr
412                                        $traductions .= '<traduction module="' . $module . '" reference="fr">' . "\n" . 
413                                                                        $liste_langues .
414                                                                        '</traduction>' . "\n";                 
415                                }
416                        }
417                }
418        }
419       
420        // On inclus les balise <traduction> dans une balise <traductions> sans attribut qui
421        // facilite le travail du parser
422        if ($traductions)
423                $traductions = '<traductions>' . "\n" . $traductions . '</traductions>' . "\n"; 
424       
425        return $traductions;
426}
427
428
429// --------------------------- CREATION DES FICHIERS RESULTAT --------------------------------------
430
431// Construit la concatenation des informations essentielles
432// contenu dans les fichiers plugin.xml et des informations relatives a chaque paquet
433// Construit egalement les informations de traduction par salvatore a destination du fichier traductions.txt
434function empaqueteur_resultats($depot, $zips) {
435        $xml = '';
436        $salvatore = '';
437        foreach($zips as $zip => $infos) {
438                list($size, $time, $source, $commit, $traductions, $descr_xml, $multis, $dtd) = $infos;
439                $f = 'empaqueteur_' . $dtd . '_xml';
440                // Bloc d'info du paquet
441                $xml .= "<archive id=\"$zip\"" . ($dtd ? " dtd=\"$dtd\"" : "") . ">
442<zip>
443        <file>$zip</file>
444        <size>$size</size>
445        <date>$time</date>
446        <source>$source</source>
447        <last_commit>$commit</last_commit>
448</zip>
449$traductions
450$descr_xml
451$multis
452\n</archive>\n\n";
453                // Bloc d'info pour Salvatore si il existe
454                if (preg_match_all("#<salvatore\s+module=['\"](\w*)['\"]\s+reference=['\"](\w*)['\"]\s*/>#i", $descr_xml, $matches)) {
455                        foreach ($matches[1] as $_i => $_module) {
456                                $salvatore .= rtrim($depot['url_serveur'], '/') . '/' . rtrim($source, '/') . '/lang/;' . 
457                                                          $_module . ';' .
458                                                          $matches[2][$_i] . "\n";
459                        }
460                }
461        }
462
463        // On complete les archives avec les informations du depot
464        // Pour l'instant ce bloc n'implemente pas la nouvelle DTD
465        if (!$xml) return '';
466        $xml_depot = '';
467        foreach ($depot as $_balise => $_valeur) {
468                $xml_depot .= "<$_balise>$_valeur</$_balise>\n";
469        }
470        if ($xml_depot) 
471                $xml_depot = "<depot>\n$xml_depot</depot>\n";
472        $xml = "$xml_depot
473<archives>
474$xml
475</archives>";
476
477        if($salvatore){
478        // On ajoute une en-tete au fichier genere
479        $salvatore = 
480"# LISTE DES PLUGINS / SQUELETTES UTILISANT SALVATORE
481# --------------------------------------------------
482# Depot : " . $depot['titre'] . "
483# Generation par Smart-Paquets le " . date('d-m-Y H:i') . "
484#\n" . $salvatore;
485        }
486        return array($xml, $salvatore);
487}
488
489// Fonction creant le fichier xml recapitulant toutes les archives creees
490//
491// Ne pas le reecrire si rien de neuf, c'est + efficace et ca permet
492// au detecteur de nouvelle version d'utiliser If-Modified-Since.
493//
494// Attention, file_put_contents fait ce qu'il veut de certaines lignes vides
495// http://fr2.php.net/manual/fr/function.file-put-contents.php
496//
497// $nom_fichier : nom du fichier xml recapitulant toutes les archives
498// $archives    : contenu du nouveau fichier xml resultant des archives creees
499// $dir_paq             : repertoire de depot des paquets crees
500// $dir_repo    : repertoire racine des sources extraits du repository
501//
502// return               : aucun
503function empaqueteur_xml_archives($nom_fichier, $archives, $dir_paq, $dir_repo)
504{
505        $taille = strlen($archives);
506        $f = $dir_paq . $dir_repo . $nom_fichier;
507        $old = (file_exists($f)) ? trim(file_get_contents($f)) : '';
508        if ($old != $archives) {
509                echo_trace("Nouveau $f de taille $taille");
510                file_put_contents($f, $archives);
511                return;
512        }
513        echo_trace("$f intact (taille: $taille)");
514}
515
516
517// Fonction creant le fichier des traductions de Salvatore
518//
519// Ne pas le reecrire si rien de neuf, c'est + efficace et ca permet
520// au detecteur de nouvelle version d'utiliser If-Modified-Since.
521//
522// Attention, file_put_contents fait ce qu'il veut de certaines lignes vides
523// http://fr2.php.net/manual/fr/function.file-put-contents.php
524//
525// $nom_fichier : nom du fichier des traductions
526// $salvatore   : contenu du nouveau fichier des traductions Salvatore
527// $dir_paq             : repertoire de depot des paquets crees
528// $dir_repo    : repertoire racine des sources extraits du repository
529//
530// return               : aucun
531function empaqueteur_salvatore($nom_fichier, $salvatore, $dir_paq, $dir_repo)
532{
533        $taille = strlen($salvatore);
534        $fichier = $dir_paq . $dir_repo . $nom_fichier;
535        $old = (file_exists($fichier)) ? trim(file_get_contents($fichier)) : '';
536        if ($old != $salvatore) {
537                echo_trace("Nouveau $fichier de taille $taille");
538                file_put_contents($fichier, $salvatore);
539                return;
540        }
541        echo_trace("$fichier intact (taille: $taille)");
542}
543
544
545// Fonction creant le fichier index des logos permettant d'afficher une page
546// de controle des logos
547//
548// Le fichier est recree systematiquement
549//
550// $nom_fichier : nom du fichier index des logos
551// $dir_paq             : repertoire de depot des paquets crees
552// $dir_repo    : repertoire racine des sources extraits du repository
553//
554// return               : aucun
555function empaqueteur_index_logos($nom_fichier, $dir_paq, $dir_repo)
556{
557        $contenu = '';
558        $logos = array_merge(glob($dir_paq . $dir_repo . '*.png'),
559                                                glob($dir_paq . $dir_repo . '*.gif'),
560                                                glob($dir_paq . $dir_repo . '*.jpg'));
561        foreach($logos as $_logo)
562                $contenu .= '<img src="' . basename($_logo) . '" />' . "\n";
563
564        $fichier = $dir_paq . $dir_repo . $nom_fichier;
565        if(strlen($contenu)){
566                file_put_contents($fichier, $contenu);
567                echo_trace("Nouvel index cree : " . count($logos) . " logos");
568        }else{
569                echo_trace("Aucun logo trouvés, pas d'index créé");
570        }
571}
572
573?>
Note: See TracBrowser for help on using the repository browser.