2009/10/27

VirtualBox sur un hôte FreeBSD

Au boulot pour les mails, nous utilisons Br0tchus Notes, un espèce de daube infâme qui te pique ta ram pire qu'un firefox dans ces mauvais jours, bref.

Mon problème c'est que mon Desktop c'est du FreeBSD et que les gens de chez IBM, il ne fournissent de clients que pour Linux (si on ne considère que les environnements libre) - le java ça ne devait pas permettre de faire des applis qui tourne chez tout le monde ??? (oui il y a des vrais morceaux d'eclipse donc de java dans les derniers clients Notes)... bref -

VirtualBox ayant été porté récemment sous FreeBSD avec le support des extensions Vt-X je me suis donc lancé dans la virtualisation d'une debian minimaliste qui n'aura pour seul but que de lancer le client Notes et de le confiner en RAM afin qu'il ne me pique pas tout ce que j'ai de disponible sur ce Desktop.

Pour cela je l'ai donc installé depuis les ports (il faudra faire attention pour lancé les VMs à bien avoir mounté /proc - oui le ports n'est pas encore super propre, mais on fera avec). Comme c'est déjà super long à compiler je l'ai compilé en enlevant le support QT4, en effet la GUI n'apporte pas grand chose à cette application et en plus elle ne permet pas d'accéder à des fonctionnalités intéressantes de VBox.

Pour finir afin d'être plus souple j'ai utilisé les volumes zfs comme disques pour l'invité.

Installation de virtualbox

$ make -C /usr/ports/emulators/virtualbox config

Choisissez les options qui vous plaisent

$ make -C /usr/ports/emulators/virtualbox install clean

Si tout ce passe bien vous disposez maintenant de virtualbox sur votre machine.

Préparation du disque d'accueil de l'invité

Règle devfs

Pour que les volumes pour l'invité puisse être modifié par l'application virtualbox, ils doivent appartenir au groupe vbox, devfs nous permet de le faire à la volée, pour cela, dans le fichier /dev/devfs.rules :

[localrules=1]
add path 'zvol/vbox/*' mode 0660 group vbox

Ne pas oublier de modifier /etc/rc.conf pour qu'il le prenne en compte :

devfs_system_ruleset="localrules"

Un petit redémarrage de devfs pour finir :

$ /etc/rc.d/devfs restart

Création du volume

5G suffirons largement pour notre installation et encore je suis très large

$ zfs create -V 5G vbox/debian

Nous disposons maintenant d'un disque qu'il ne reste plus qu'à ajouter au pool de disques VirtualBox :

$ VBoxManage internalcommands createrawvmdk -filename melebian.vmdk -rawdisk /dev/zvol/vbox/debian
$ VBoxManage registerimage disk debian.vmdk

Création de la machine virtuelle

Création de la VM sans disque

Nous allons donc créer la VM pour qu'elle support les extensions VT-x et qu'elle soit limitée à 256Mo de RAM il ne s'agirait pas non plus que notes se sente trop à son aise.

$ VBoxManage createvm -name debianVM -register
$ VBoxManage modifyvm debianVM --ostype debian -memory 256M
$ VBoxManage modifyvm debianVM --vtxvpid on

Nous allons aussi déporter le port 22 de l'invité sur le port 2222 local afin de se simplifier la tâche pour le réseau (on laisse le réseau par défaut de virtualbox)

$ VBoxManage setextradata debianVM "VBoxInternal/Devices/pcnet/0/LUN#0/Config/ssh/GuestPort" 22
$ VBoxManage setextradata debianVM "VBoxInternal/Devices/pcnet/0/LUN#0/Config/ssh/HostPort" 2222
$ VBoxManage setextradata debianVM "VBoxInternal/Devices/pcnet/0/LUN#0/Config/ssh/Protocol" TCP

Ajout du disque à la nouvelle VM et de l'iso de l'installeur

Tout d'abord on liste les disques disponibles dans le pool pour récupérer son identifiant :

$ VBoxManage list hdds
UUID:         b6db4102-90fd-4073-ae61-c1c57556bb85
Format:       VMDK
Location:     /home/bapt/debian.vmdk
Accessible:   yes

Il suffit maintenant de le rajouter :

$ VBoxManage modifyvm debianVM -hda b6db4102-90fd-4073-ae61-c1c57556bb85

On enregistre l'iso dans le pool VirtualBox :

$ VBoxManage registerimage dvd /home/bapt/Desktop/debian-501-i386-netinst.iso

Et on l'ajoute de la même manière à la VM

$ VBoxManage list dvds
UUID:       b3329255-221a-4bb6-b1f4-be2d4bdc0f2f
Path:       /home/bapt/Download/debian-501-i386-netinst.iso
Accessible: yes

$ VBoxManage modifyvm debianVM -dvd b3329255-221a-4bb6-b1f4-be2d4bdc0f2f -boot1 dvd

Installation de l'invité

Pour l'installation de l'invité, on démarrera en mode sdl pour la suite ça ne sera plus nécessaire :

$ VBoxManage startvm debianVM --type sdl

Ou

$ VBoxSDL startvm debianVM

il ne vous reste plus qu'à faire votre installation debian normale à laquelle vous ajouterez votre client br0tchus notes et le configurerez.

afin que votre VM puisse accéder au disque de l'hôte sans se prendre la tête, VirtualBox prévoie un mécanisme bien sympathique :

$ VBoxManage sharedfolder add debianVM -name share -hostpath /home/bapt/sharedvm

Pour y accéder depuis votre debian, il faudra installer les guestutils

$ apt-get install virtualbox-ose-guest-modules virtualbox-ose-guest-utils

Puis dans le /etc/fstab de l'invité

share            /home/bapt/sharedHost    vboxsf  uid=bapt,gid=bapt       0       0

Maintenant lorsque vous démarrerez votre VM vous le ferez de la manière suivante :

$ VBoxManage startvm debianVM --type headless 

Ou

$ VBoxHeadless startvm debianVM

Et pour se connecter à la VM depuis l'hôte :

$ ssh -Y -p 2222 bapt@localhost 

lancez notes ou votre application désirée.

Comme je suis un gentil lutin j'ai partagé tout ça de manière plus générique sur GCU

2009/10/20

CBlog bientôt une release donc un ports

Une nouvelle fonctionnalité vient de faire son apparition dans CBlog : la possibilité de pouvoir désactiver les commentaires via un simple "Comments: false" dans l'entête d'un message (à la demande de rhaamo - oui il y a au moins deux utilisateurs de CBlog :)).

En fait c'est encore mieux que ça, un nouveau champs Posts.nb.allow_comments est disponible dans le HDF (datafile) du coup vous pouvez faire ce que vous voulez avec dans votre template, il correspond au contenu de l'entête Comments:. Dans le template d'exemple si il est égale à false, il n'affiche pas le formulaire de commentaires.

Il me reste deux fonctionnalités à implémenter pour faire une release 1.0 :

Bien sûr il reste toujours du nettoyage a faire pour rendre plus propre et robuste le code, de la documentation :)

En ce qui concerne CPlanet il n'y a plus que du nettoyage car je ne vois pour le moment aucun besoin de rajouter de fonctionnalitées.

Dans tous les cas dès la release venue, un joli ports FreeBSD fera son entrée.

Toute contribution est la bienvenue, surtout que pour le moment le code n'a été testé que sous FreeBSD.

2009/08/28

Reconstruire les paquets cassés

Voici un petit script ZSH pour rechercher les binaires systèmes qui ne trouvent pas les bibliothèques dont ils dépendent et les reconstruire en utilisant portmaster.

#!/usr/local/bin/zsh

typeset -a torebuild

rep=(/usr/local/bin/**/*(.))
rep+=(/usr/local/lib/**/*.so(.))
rep+=(/usr/local/sbin/**/*(.))

for bin ($rep) {
    file $bin | grep -q "ELF" && {
        ldd =$bin | grep -q "not found" && {
            torebuild+=$(pkg_info -qoW $bin)
        }
    }
}
portmaster -f ${(u)torebuild}

2009/08/27

Convertir l'arbre CVS des ports en git

Voulant pouvoir jouer tranquillement avec les ports via git, je me suis dit que j'allais convertir les CVS des ports en git tout simplement.

Récupération du CVSROOT

Créer le fichier de config suivant pour csup

*default host=cvsup.free.org
*default base=/var/db
*default prefix=/usr/portsdev
*default release=cvs
*default delete use-rel-suffix

*default compress

ports-all

Puis récupérer le cvsroot :

$ csup cvsroot-supfile

Récupération et construction de parsecvs

Récupérer les sources

$ git clone git://anongit.freedesktop.org/~keithp/parsecvs

Contruire les lib git qui seront nécessaires, sans les installer.

$ make -C /usr/ports/devel/git

Modifier le Makefile de parsecvs pour qu'il ressemble à celui-ci

GCC_WARNINGS1=-Wall -Wpointer-arith -Wstrict-prototypes
GCC_WARNINGS2=-Wmissing-prototypes -Wmissing-declarations
GCC_WARNINGS3=-Wnested-externs -fno-strict-aliasing
GCC_WARNINGS=$(GCC_WARNINGS1) $(GCC_WARNINGS2) $(GCC_WARNINGS3)
GITPATH=/usr/ports/devel/git/work/git-1.6.4
CFLAGS=-O2 -g $(GCC_WARNINGS) -I$(GITPATH) -DSHA1_HEADER='<openssl/sha.h>' -I/usr/local/include
LIBS=-L$(GITPATH) -lgit $(GITPATH)/xdiff/lib.a -lssl -lcrypto -lz -liconv -L/usr/local/lib
YFLAGS=-d -l
LFLAGS=-l

OBJS=gram.o lex.o parsecvs.o cvsutil.o revdir.o \
        revlist.o atom.o revcvs.o git.o gitutil.o rcs2git.o \
        nodehash.o tags.o tree.o

parsecvs: $(OBJS)
        cc $(CFLAGS) -o $@ $(OBJS) $(LIBS)

$(OBJS): cvs.h
lex.o: y.tab.h

lex.o: lex.c

y.tab.h: gram.c

clean:
        rm -f $(OBJS) y.tab.h gram.c lex.c parsecvs
install:
        cp parsecvs edit-change-log ${HOME}/bin

Construction et installation de parsecvs

$ gmake
$ cp parsecvs edit-change-log /usr/local/bin

Conversion du CVSROOT en git

$ cd /usr/portsdev/ports

Si vous utilisez zsh :

$ print -l **/*,v | parsecvs

Sinon

$ find . -name "*,v" -print | parsecvs

Attention c'est long, très long : 17h30 sur un Q6600 avec 4Go de RAM et un disque SATA 150 en zfs Le facteur principal est la vitesse du disque dur en effet la consommation de RAM et CPU est négligeable comparée à l'utilisation disque.

Une fois cette étape terminée vous disposez d'un répertoire git fonctionnel mais énorme : plus de 4Go

Repack du rep

$ git repack -a -f -d -l

Cette étape est très longue aussi et dépend de la vitesse de votre disque pour beaucoup. Ici ça a pris 28h50

Une fois cette étape finie vous voila avec un répertoire git de 400M ce qui est quand même beaucoup mieux.

Préparation pour les mises à jour

Alors comme cvsps foire prodigieusement souvent via git cvsimport, il faut le lancer de côté :

$ export CVS_RSH=ssh
$ export CVSROOT=anoncvs@anoncvs.fr.FreeBSD.org:/home/ncvs
$ cvsps -x --norc -u -A ports > /tmp/cvsps.out

Mise à jour de l'arbre git

$ git cvsimport -o master -P /tmp/cvsps.out ports

Vous voila avec un git à jour, pour continuer à mettre à jour, recommencer les deux dernières étapes.

En un seul coup pour zsh :

$ git cvsimport -o master -P <(cvsps -x --norc -u -A ports) ports

2009/08/27

zcp un wrapper pour cp

L'autre jour sidh me demandait si je n'avais rien en zsh pour pouvoir suivre la progression d'un cp volumineux et je n'avais rien, mais j'ai trouvé l'idée intéressante. Un petit man cp plus tard, je me rend compte que le cp de FreeBSD il est beau et bien foutu, en lui envoyant un SIGINFO il nous dis ce qu'il fait et ou il en est. De là a wrapper tout dans un petit script zsh il n'y avait qu'un pas.

De plus zsh permet de créer un tty virtuel (zpty) dans lequel on peut exécuter des commandes et interagir, du coup, voici un petit script bien pratique :

#!/usr/local/bin/zsh
setopt extendedglob
zmodload zsh/zpty
zpty copy "cp $@ 2>&1"     
ZPTYPID=${${=${(M)${(f)"$(ps -o pid,ppid,command)"}:#[[:space:]]#[[:digit:]]##[[:space:]][[:space:]]#$$*zsh*}}[1]}
CPPID=${${=${(M)${(f)"$(ps -o pid,ppid,command)"}:#[[:space:]]#[[:digit:]]##[[:space:]][[:space:]]#${ZPTYPID}*cp*}}[1]}
line=""
while [ : ]
do
    zpty -rt copy out
    if [[ $#out -gt 0 ]]
    then
        newline=${${=${out}}[0,-2]}
        percent=${${=${out}}[-1]}
        if [[ -z $line || "x$newline" != "x$line" ]]
        then
            [[ -n $line ]] && print "${line}: done"
            line=$newline
            print "${line}: ${(l: ::4:)percent}\c"
        else
            print "\r${line}: ${(l: ::4:)percent}\c"
        fi
    fi
        kill -SIGINFO $CPPID 2>/dev/null || break
done
[[ -n $line ]] && print "${line}: done"
zpty -d copy

la sortie donne : # zcp toto.iso bla/ toto.iso -> bla/toto.iso: 48%

UPDATE: Apparemment ça ne fonctionne qu'avec zsh 4.3.10+

2009/08/05

Du nouveau sous le capot

Depuis quelques temps déjà je me suis mis à essayer de faire du C pour de vrai. Pour cela il me fallait un vrai projet, alors je me suis dit tiens un planet BSD pour les BSDistes actifs francophone ça sera pas mal, du coup j'ai codé CPlanet. Ce qui m'a fait découvir une bibliothèque vraiment choupi s'il en ait pour faire du Web en C : clearsilver.

Résultat : planet.etoilebsd.net

CPlanet est donc un aggrégateur de flux rss et atom (merci libmrss) qui génère un site statique. Il utilise un fichier de conf vraiment simplissime. C'est la solution pour qui souhaite mettre en place un planet sans contrainte, puisque celui-ci n'utilise aucun langage de script, ni de base de données, juste un tout petit binaire.

Tout ça m'a bien motivé alors vlati pas que je me dis que blosxom c'est sympa, mais ça fait pas tout ce que je veux et en plus ça m'oblige à ajouter des lib perl de partout pour les plugins. Je ressors donc mon plus beau vim, mon petit clearsilver tout choupi qui ne me quitte plus et je me lance. Cerise sur le gâteau, je découvre discount, une jolie lib pour transformer du texte en html en suivant la syntaxe markdown.

Resultat : un moteur de blog en C (sous la forme d'un cgi) qui ne nécessite donc pas de langage de script, qui ne nécessite pas non plus de base de donnée toute bloatée. Il reprend le format de post de bloxsom si vous l'utilisiez avec les plugins tags et markdown.

CBlog est bien sûr libre sous license BSD.

Ce blog est donc maintenant propulsé par CBlog version de développement j'ai changé mes rewrite rules afin que le minimum de liens soit cassé.

Et non pour le mauvaise langue ce n'est pas à cause de cblog que mon site de sera pas disponible pendant 15 jours à compter de samedi, c'est pour cause de vacances et de coupure de machine.

EDIT CPlanet et CBlog sont écologiques !!! comme ils ne sont pas plein de bloat de partout, ils vous font économiser du CPU donc des Watts, alors il n'y a aucune raison de ne pas les utiliser.

PS: si vous avez des flux pour le planet à proposer je suis preneur à noter que si les gens sur le planet doivent être francophone, leurs posts n'ont pas besoin de l'être.

2009/06/11

Zsh avec Ncurses c'est beau

Depuis un moment déjà zsh a un nouveau module zsh/curses qui permet de faire de belles interface en ncurses directemet en script zsh. Depuis le temps que je voulais essayer, j'ai fini par me décider.

Pour mon premier bout de zsh/curses, j'ai décider de me faire un mixer tout joli utilisant mixer(8), je m'inspire donc de rexima dont j'aime bien l'ui et je suis donc parti pour me faire un zmixer.

De plus j'ai découvert que l'on pouvais faire du ZSH avec une syntaxe "un peu objet" alors voila le code obtenu :

#!/usr/bin/env zsh

zmodload zsh/curses

zmix()
{
    local mixer
    local -a zmix_dev
    integer y
    integer posy
    integer length
    #get list of devices
    zmix.draw()
    {
        zcurses addwin main $(( $LINES - 2 )) $(( $COLUMNS - 2 )) 1 1
        title="zmixer"
        zcurses move main 1 $(( ($COLUMNS - 2 - $#title) / 2 ))
        zcurses string main $title
        y=4
        for dev ($zmix_dev);do
            y+=1
            zcurses move main $y 5
            zcurses string main $dev
            zcurses move main $y 15
            zcurses string main ":"
            # Set the recording device
            if [[ "x$dev" = "x$record" ]]; then
                zcurses addwin record 1 1 $(( y + 1 )) 4 main
                zcurses attr record red/black bold
                zcurses string record "*"
            fi
            level=${${(f)"$(/usr/sbin/mixer -s $dev)"}[(w)2]}
            numlevel=${${(s#:#)level}[1]}
            zcurses move main $(( y )) 17
            line="|"
            zcurses string main "[${(r:$length::-:)${(l:$(( numlevel / 2))::=:)line}}] ($level)"
        done
        if (( posy == 0 ));then
            posy=5
        fi
        zmix.sel $posy
        zcurses refresh main
    }
    zmix.listen()
    {
        while true;do
            if [[ -z $key ]];then
                zcurses input main REPLY key
            fi
            newkey=$key
            key=
            case $newkey in
                (UP)
                if (( posy <= 5 )); then
                    zmix.sel $y
                else
                    zmix.sel $(( posy - 1 ))
                fi
                ;;
                (DOWN)
                if (( posy >= y )); then
                    zmix.sel 5
                else
                    zmix.sel $(( posy + 1 ))
                fi
                ;;
                (LEFT)
                dev=$zmix_dev[$(( posy - 4 ))]
                mixer $dev -1 2>&1 >/dev/null
                zmix.redraw $dev
                ;;
                (RIGHT)
                dev=$zmix_dev[$(( posy - 4 ))]
                mixer $dev +1 2>&1 >/dev/null
                zmix.redraw $dev
                ;;
                ("")
                if [[ -z $REPLY ]];then
                    zcurses delwin record
                    zcurses delwin main
                    zcurses clear stdscr redraw
                    zcurses refresh stdscr
                    zmix.draw
                else
                    break
                fi
                ;;
            esac
        done
    }
    zmix.sel()
    {
        zcurses move main $posy 0
        zcurses string main "  "
        posy=$1
        zcurses move main $posy  0
        zcurses string main "->"
        zcurses refresh main
    }
    zmix.redraw()
    {
        dev=$1
        level=${${(f)"$(/usr/sbin/mixer -s $dev)"}[(w)2]}
        numlevel=${${(s#:#)level}[1]}
        zcurses move main $posy 16
        zcurses clear main eol
        level=${${(f)"$(/usr/sbin/mixer -s $dev)"}[(w)2]}
        numlevel=${${(s#:#)level}[1]}
        zcurses move main $posy 17
        line="|"
        zcurses string main "[${(r:$length::-:)${(l:$(( numlevel / 2))::=:)line}}] ($level)"
        zcurses move main $posy 2
        zcurses refresh main
    }
    #Constructor
    {
        length=50
        mixer=(${=${(f)"$(/usr/sbin/mixer -S)"}})
        for line ($mixer);do
            [[ -n ${line:#*:*:*} ]] && continue
            zmix_dev+=${${(s#:#)line}[1]}
        done
        record=$mixer[$#mixer]
        zcurses init
        zmix.draw
        zmix.listen
    } always
    {
        #cleanup all windows
        for win ($zcurses_windows);do
            [[ -z ${win:#(main|stdscr)} ]] && continue
            zcurses delwin $win
        done
        zcurses delwin main
        zcurses end
    }
}
zmix

Je sais pas vous mais moi je trouve ça beau.

Le résultat en image :

zmixer

EDIT: Promis dès que ça sera plus propre ça ira dans zen

2009/05/27

Migrer sur du Full ZFS

Depuis peu : les derniers commit en -STABLE ont eu lieu ce WE, il est possible d'avoir un FreeBSD 100% en ZFS, avant il y avait une solution qui consistait à passer ses disques du format MBR au format GPT, mais nous pouvons maintenant le faire directement sur du MBR.

De plus il est possible de booter sur des RAID-Z ou des MIRROR zfs.

Attention : la manipulation suivante doit se faire avec un système 7-STABLE ou 8-CURRENT très récent, de plus il faut rajouter l'option LOADER_ZFS_SUPPORT=YES dans le /etc/src.conf ou /etc/make.conf suivant les goûts afin que le loader sache travailler sur du ZFS.

Dans le cas présent nous allons donc migrer un système FreeBSD-Current tout frais mono-disque d'une installation UFS vers ZFS. Dans mon cas je voulais changer le disque dur au passage donc tout est parfait.

Création du POOL

Après avoir ajouter le disque (ici ad6) dans la machine, et de l'avoir vidé de toutes ses éventuelles partitions, nous allons créer notre zpool, il est donc possible ici de faire du mirror ou des raidz :

$ zpool create tank ad6
$ zpool export tank

Ajout de ZFSBOOT dans le mbr

$ dd if=/boot/zfsboot of=/dev/ad6 bs=512 count=1
$ dd if=/boot/zfsboot of=/dev/ad6 bs=512 skip=1 seek=1024

Si vous voulez booter sur un mirror zfs n'oubliez pas de faire la même chose sur l'autre disque.

Réactivation du pool

$ zpool import tank

Vous pouvez maintenant créer tous les FS que vous voulez dedans. attention si vous décidez de créer des FS spécifique pour /usr ou /var, vous devrez changer le mountpoint après un reboot en mode single sur le nouveau disque ZFS.

dans mon cas j'ai créé un swap de 1G :

$ zfs create -V 1g tank/swap
$ zfs set org.freebsd:swap=on tank/swap

La dernière option permet d'activer le swap automatiquement au boot lors de l'activation du zpool tank.

Et comme les checksum ça sert à rien sur du swap :

$ zfs set checksum=off tank/swap

migration des données

Pour migrer les données vous avez tout le choix des outils habituels, dans mon cas j'ai pris rsync ce coup ci et j'y suis allé gaiement à coup de rsync, par exemple :

$ rsync -av /boot /tank
$ ...
$ rsync -av /var /tank

En ne migrant pas bien entendu /dev ou autre FS "particulier".

Finalisation

pour finir il faut vous assurez que

si ce dernier n'y est pas ou que vous voulez le recréer par précaution :

$ zpool export tank && zpool import tank
$ zfs mount -a
$ cp /boot/zfs/zpool.cache /tank/boot/zfs/zpool.cache

Si tout ça est bon, il ne nous reste plus qu'à préciser à votre zfs quel est votre FS de boot

$ zpool set bootfs=tank tank

et Enfin de ne pas spécifier de point de montage pour tank :

$ zfs set mountpoint=legacy tank

c'est bon vous pouvez redémarrer sur le nouveau disque en 100% ZFS et supprimer votre disque UFS.

2009/04/29

Colorize la vie

Blosxom est très sympathique, très simple à utiliser, dispose de plein de plugin bien foutu, mais j'avais quand même un reproche à lui faire : impossible de trouver un plugin de colorisation syntaxique.

Bref je me dis que ça doit pas être trop compliqué à faire, alors je sors mon plus beau vim et je m'apprête à en code un moi même.

Un petit tour sur le CPAN et je trouve deux projet permettant de mettre des belle couleurs sur du texte :

Je choisis le second car Text::VimColor fait des appels système à vim ce qui ne me plait pas. Ensuite je jette un oeil sur la doc développeur de blosxom, et je me rends vite compte que c'est très très simple de faire de nouveau plugin.

Pour la rédaction j'utilise Markdown, celui-ci génère des blocs de code html entre les balises <pre><code>...</code></pre>, Il ne me reste plus qu'a récupérer le contenu de ces balises, positionner un marqueur pour le choix du langage, et à passer le tout dans la Syntax::Highlight::Engine::Kate, puis de le remettre dans la page d'origine.

Ce qui donne colorize le marquer à mettre en début de bloc est [_langage_], la liste des langages est disponibles dans la doc de Syntax::Highlight::Engine::Kate

2009/04/29

On Change !!

J'en avais ras le bol de l'hébergement Free, j'avais surtout marre de ne pas pouvoir éditer mes billets en vim proprement sans passer par des outils/add-ons tordus, j'ai donc mis un petit blosxom directement chez moi, après l'ajout de quelques plugins : antispam, tags, tagcloud, metaclear, metamail, paging, entries_index, Markdown et writeback, je me retrouve avec un beau blog en perl pour lequel j'édite les news en vim directement, que demande le peuple.

J'ai quand même du me coder moi même un petit plugin pour faire de la colorisation syntaxique des bloques de codes, mais quoi de plus simple avec perl et Syntax::Highlight::Engine::Kate.

Un petit script perl maison pour importer les données de dotclear via l'interface XMLRPC :

use Data::Dumper;
use Encode;
use Date::Manip;
use HTML::WikiConverter;
use RPC::XML::Client;
use RPC::XML;
use strict;

my $xmlrpc = RPC::XML::Client->new('http://baptux.free.fr/index.php?xmlrpc/default');
my $request = RPC::XML::request->new("metaWeblog.getRecentPosts",RPC::XML::string->new("1"),RPC::XML::string->new("bapt"),RPC::XML::string->new("secret"),RPC::XML::int->new(25));
my $result=$xmlrpc->send_request($request);
my %entries={};
for my $value (@{$result->value}) {
        my $filename=encode("utf-8",decode("iso-8859-1",$value->{title}));
        my $title=encode("utf-8",decode("iso-8859-1",$value->{title}));
        $filename =~ s/\s+/_/g;
        $filename =~ s/é/e/g;
        $filename =~ s/è/e/g;
        $filename =~ s/à/a/g;
        $filename =~ s/"//g;
        $filename =~ s/'//g;
        $filename =~ s/\(//g;
        $filename =~ s/\)//g;
        open(FILE,">data/$filename.txt");
        print FILE "Title: $title\n";
        print FILE "Tags: ",$value->{mt_keywords},"\n\n";
        my $content = encode("utf-8",decode("iso-8859-1",$value->{description}));
        $content =~ s/<br\ \/>/<br>/g;
        my $wc = new HTML::WikiConverter( dialect => 'Markdown' );
        print FILE $wc->html2wiki( $content );
        close FILE;
        print $filename, $value->{dateCreated},"\n";
        my $date = ParseDate($value->{dateCreated});
        $entries{"/usr/local/www/virtualhosts/blog/data/$filename.txt"}=UnixDate($date,"%s");
}
open(ENTRIES,">plugins/state/.entries_index.index");
print ENTRIES Dumper \%entries;
close ENTRIES;

Ce script se connecte sur mon ancien blog récupère la liste des posts (25 car je n'en avais que 25) crée dans un répertoire data et fichier .txt pour chaque post, les convertis au format markdown et en utf8.

Afin de conserver les dates des posts, il crée aussi un fichier plugins/state/.entries_index.index contenant les dates epoch de création de chaque post.

Ce script n'est pas parfait j'ai du faire quelques manipulations à la main pour finaliser le formattage des posts, mais il fait quand même le plus gros du boulot.

Par contre j'ai perdu tous les commentaires, dommage.

Dans quelques jours je vous parlerai plus en détail du petit plugin de colorisation syntaxique

EDIT : oui je sais mon code perl est pas beau, on peut faire plus simple et beau mieux :)

EDIT2 : il n'y a pas de grosse base de donnée SQL qui pu derrière, juste du bon vieux flat file

Pages : 1 2 3 4 5 6 7