La Geek Attitude

Mes fichiers de conf (Vim, Zsh, xmonad et git)

Kévin G. — Sat, 23 Apr 2011 20:42:25 +0000

Ayant récemment dépoussiéré mes quelques fichiers de configuration, c’est l’occasion pour moi d’en parler ici. Au programme : vim, zsh, xmonad et git !
Pour les détails des conf, je vous renvoie au README du repo Github. Parce que oui, tout est sur un repo : easier to share .
Vous retrouverez en gros du oh-my-zsh, du xmonad intégré à Gnome et un Vim aux petits oignons.

En ce qui concerne mes sources d’inspiration, voici les principales :

William Durand
Carpe Hora (j’y fait mon stage de DUT et nos bureaux sont occupés par quelques bons barbus )
Phollow
Reddit
Vi-Improved
Google

Comme d’habitude, feel free to comment & hack

Intelligence artificielle et jeux

Kévin G. — Sun, 13 Mar 2011 14:42:51 +0000

Dans le cadre du cours de graphes et jeux proposé dans mon IUT, j’ai eu l’occasion de découvrir un nouveau domaine : celui des intelligences artificielles.

En utilisant comme support un jeu réalisé par nos prédécesseurs, le Jungle (aka Dou Sou Qi), nous avons mis en pratique nos connaissances sur les IA. Nous en avons profité pour écrire un rapport (en anglais) sur le travail réalisé lors des TP et sur les techniques utilisées dans nos IAs.
Vous trouverez dans ce rapport des explications sur les techniques les plus communes de construction d’IA pour un jeu simple (deux adversaires, pas de hasard), ainsi que quelques pistes pour améliorer ces algorithmes en les couplant à l’intelligence humaine (en partant du principe qu’elle existe :-°).

Si selon vous les termes Minimax, Alpha-Beta et un rapport en anglais ne font pas mauvais ménage, alors téléchargez mon rapport sur la création d’une intelligence artificielle !

Projet tutoré : un saut dans la programmation logique

Kévin G. — Mon, 08 Nov 2010 20:21:30 +0000

Vendredi dernier nous ont été attribués « équitablement » (ie : au hasard) nos sujets de projet tutoré de seconde année d’IUT Informatique.

Je dois avouer qu’après avoir eu vent de certains des sujets, j’étais un peu inquiet quant à l’intérêt de ce sur quoi j’allais devoir travailler … Faire un site web pour une association de jeu vidéo relève pour moi plus d’un petit job que ferait un étudiant pour payer ses études que d’un réel sujet de projet.
Heureusement pour moi et mes partenaires, le sort en a décidé autrement !

En effet, le projet que nous devrons réaliser dans les prochaines semaines consiste tout bonnement à créer un langage de programmation. Et pas n’importe quel type de langage : un langage de programmation logique. Deux de mes profs semblent être des amateurs de Prolog, et comptent bien nous faire partager leur penchant pour ce langage.
Ça tombe bien, ce sujet nous a tout de suite emballé ! Il faut aussi prendre en compte le fait qu’entre créer un langage et faire du Windev, y a pas photo ! ;p

Ce projet est donc pour mes partenaires et moi l’occasion de découvrir à la fois les dessous d’un langage et le monde de la programmation logique. Et que ce soit l’un ou l’autre, on a de quoi faire \o/

Nous avons ce matin même commencé à nous intéresser à Prolog et à écrire nos premiers faits, règles et prédicats prologuiens. Sont aussi apparus devant nos yeux les BNF (nécessaires pour décrire la grammaire d’un langage), des termes barbares tels que clauses de Horn, SLD-résolution, l’unification, le backtracking, le pattern-matching et j’en oublie surement des plus tordus.

Tout ça pour dire que le grand saut dans la programmation logique que nous venons de faire nous enthousiasme beaucoup, mais qu’étant donnée l’étendue du problème qui nous est posé nous risquons très vite de déchanter …

Quoi qu’il en soit, l’heure est encore à l’apprentissage de Prolog et des notions qui lui sont liées, viendra ensuite l’heure de l’écriture d’une BNF et il sera vraiment temps de se documenter en profondeur sur les notions que j’ai décrites pour commencer à réfléchir à notre moteur d’inférence (et voilà, déjà un barbarisme que j’ai oublié de citer dans le paragraphe précédent).

L’aventure commence, stay tuned !

P.S : vous n’avez pas réussi à trouver la moindre logique entre mes paragraphes, ne vous inquiétez pas, il n’y en a tout simplement aucune !

Convertir du HTML en PDF avec Qt

Kévin G. — Sat, 09 Oct 2010 08:55:45 +0000

Dans le cadre d’un projet en C++ utilisant Qt pour la partie GUI, il s’est posé la question de savoir comment générer à partir de code HTML et CSS un jôôli PDF.

Voici la solution retenue :

QWebView view; // sera chargé de rendre le code HTML
QPrinter printer; // et lui s'occupera de l'impression du rendu

// configuration du printer : format A4, rendu en PDF
printer.setPageSize(QPrinter::A4);
printer.setOutputFormat(QPrinter::PdfFormat);
printer.setOutputFileName("mon_super.pdf"); // nom par défaut, changez le ! =)

// on donne au QWebView le code HTML à interpréter
view.setHtml("test titretitre
contenu");

// si on veut imprimer une page web
// view.load(new QUrl("http://www.kevingomez.fr"));

// affichage d'une boite de dialogue pour donner quelques options à l'utilisateur
// il peut par exemple changer le nom du fichier, définir quelles pages seront imprimées, etc.
QPrintDialog printDialog(&printer, this);
if(printDialog.exec() == QDialog::Accepted) {
    view.print(&printer); // impression de la page en utilisant le printer
}

Et voilà, nous avons très simplement généré notre PDF ! Nous pouvons bien évidemment utiliser l’URL d’une page pour générer le fichier en utilisant la méthode load(url) de QWebView.

Animes-Live.fr ouvre ses portes !

Kévin G. — Mon, 02 Aug 2010 13:56:38 +0000

Pour faire court, Animes Live est un site de streaming gratuit d’animes comme il en existe beaucoup. Mais même si ce genre de site se rencontre à la pelle sur le net, on est souvent déçu par la qualité des vidéos, des sous-titrages ou alors notre navigation est gênée par d’immondes publicités ou tchats en flash qui brillent et font du bruit.

Pour toutes ces raisons j’ai décidé d’ouvrir mon propre site. N’apparaîtront sur Animes Live que des animes de qualité, pour notre plus grand plaisir !

Pour plus d’informations, je vous renvoie à la news que j’ai (rapidement :–°) rédigé sur ledit site.

Mettre à jour son Acer Liquid vers Eclair (Android 2.1)

Kévin G. — Fri, 30 Jul 2010 16:23:29 +0000

Acer a récemment ajouté sur son centre de téléchargement une ROM officielle d’Android 2.1, ou plus communément Eclair.

L’installation de cette dernière est simple. Le tout se présente sous la forme d’une archive dans laquelle se trouve un exécutable qu’il suffit de lancer pour voir apparaître à une série instructions qu’il suffira de suivre pour installer la ROM. Tout est automatique et vous n’aurez aucune commande obscure à entrer =P

Vous serez prévenus durant l’installation mais autant vous avertir maintenant : l’utilisation de cet exécutable causera la perte de vos données personnelles stockées dans votre mobile !
Pensez donc à réaliser les sauvegardes qui s’imposent

Django via Nginx et FastCGI

Kévin G. — Sun, 18 Jul 2010 17:58:32 +0000

Maintenant que Nginx est correctement configuré pour servir Redmine, c’est au tour de Django de passer à la casserole (bah ouais, Python ou Ruby, s’pas un troll qui m’affecte des masses :–°)

Comme pour Redmine, Nginx fera office de reverse proxy, mais cette fois ce sera via FastCGI que sera servi le contenu.

Je suppose toujours que vous avez un Nginx opérationnel et Ubuntu 10.4, les manips doivent ici aussi être les mêmes pour tous les dérivés Debian. Mais cette fois j’ajouterai un pré-requis supplémentaire : un projet django fonctionnel (bawé, cay kewl si on veut tester =P)

Installation des .deb

sudo aptitude install python-django python-flup

Et voilà, on a une install’ de Django fonctionnelle, et de quoi faire tourner un serveur FastCGI.

Automatisation du lancement des projets Django

Parce qu’il peut être sympa de pouvoir lancer/stopper/relancer automatiquement tous les projets django que l’on sert, je vous mets à disposition un script à placer dans /etc/init.d/django_fastcgi et à rendre exécutable via le traditionnel :

sudo chmod +x /etc/init.d/django_fastcgi

N.B : prenez bien soin de correctement renseigner la variable DJANGO_SITES. Elle doit contenir les chemins sans le slash final vers les projets, séparés par des espaces. Chaque path présent dans DJANGO_SITES doit permettre d’accéder au fichier manage.py qui correspond au projet, ce fichier permettant dans notre cas de lancer le serveur FastCGI.

#! /bin/sh
### BEGIN INIT INFO
# Provides:          FastCGI servers for Django
# Required-Start:    networking
# Required-Stop:     networking
# Default-Start:     2 3 4 5
# Default-Stop:      S 0 1 6
# Short-Description: Start FastCGI servers with Django.
# Description:       Django, in order to operate with FastCGI, must be started
#                    in a very specific way with manage.py. This must be done
#                    for each Django web server that has to run.
### END INIT INFO
#
# Authors:  Guillermo Fernandez Castellanos
#           .
#
#           Kévin Gomez
#           .
#
# Version: @(#)fastcgi 0.1 18-Jul-2010 geek63 AT gmail.com
#          @(#)fastcgi 0.1 11-Jan-2007 guillermo.fernandez.castellanos AT gmail.com
#

#### SERVER SPECIFIC CONFIGURATION
DJANGO_SITES="/home/kevin/project_foo /home/bar/project_foo"
RUNFILES_PATH=/tmp
HOST=127.0.0.1
PORT_START=3030
RUN_AS=www-data
FCGI_METHOD=prefork
#### DO NOT CHANGE ANYTHING AFTER THIS LINE!

set -e

PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
DESC="FastCGI servers"
NAME=$0
SCRIPTNAME=/etc/init.d/$NAME

#
#       Function that starts the daemon/service.
#
d_start()
{
    # Starting all Django FastCGI processes
    PORT=$PORT_START
    for SITE in $DJANGO_SITES
    do
        PID_FILE=`echo $SITE | sed -e 's#/#_#g'`

        if [ -f $RUNFILES_PATH/$PID_FILE.pid ]; then
            echo "$SITE already running"
        else
            start-stop-daemon --start --pidfile $RUNFILES_PATH/$PID_FILE.pid \
                              --startas /usr/bin/python $SITES_PATH/$SITE/manage.py runfcgi \
                              method=$FCGI_METHOD socket=$RUNFILES_PATH/$PID_FILE.socket \
                              pidfile=$RUNFILES_PATH/$PID_FILE.pid
            chmod 400 $RUNFILES_PATH/$PID_FILE.pid
            chmod 777 $RUNFILES_PATH/$PID_FILE.socket

            echo "$SITE started"
        fi
        PORT=$(($PORT + 1))
    done
}

#
#       Function that stops the daemon/service.
#
d_stop() {
    # Killing all Django FastCGI processes running
    for SITE in $DJANGO_SITES
    do
        PID_FILE=`echo $SITE | sed -e 's#/#_#g'`

        start-stop-daemon --stop --quiet --pidfile $RUNFILES_PATH/$PID_FILE.pid && echo "$SITE stopped" \
                          || echo -n "$SITE not running"
        if [ -f $RUNFILES_PATH/$PID_FILE.pid ]; then
           rm $RUNFILES_PATH/$PID_FILE.pid
        fi
    done
}

ACTION="$1"
case "$ACTION" in
    start)
        echo "Starting $DESC:"
        d_start
        ;;

    stop)
        echo "Stopping $DESC:"
        d_stop
        ;;

    restart|force-reload)
        echo "Restarting $DESC:"
        d_stop
        sleep 1
        d_start
        ;;

    *)
        echo "Usage: $NAME {start|stop|restart|force-reload}" >&2
        exit 3
        ;;
esac

exit 0

On peut aussi faire en sorte que les projets soient automatiquement lancés dès le boot du serveur via un :

sudo update-rc.d django_fastcgi defaults

Configuration de Nginx

Un exemple de virtualhost vaut mieux qu’un long discours, donc le voici :

server {
    listen      80;
    server_name domain.tld;

    location / {
        fastcgi_pass unix:/tmp/_home_bar_project_foo.socket;

        # à vous de voir si vous avez besoin de plus de choses
        fastcgi_param PATH_INFO         $fastcgi_script_name;
        fastcgi_param SERVER_PORT       $server_port;
        fastcgi_param SERVER_PROTOCOL   $server_protocol;
        fastcgi_param SERVER_NAME       $server_name;
        fastcgi_param REQUEST_METHOD    $request_method;
        fastcgi_param CONTENT_TYPE      $content_type;
        fastcgi_param CONTENT_LENGTH    $content_length;
    }

    # on sert directement les fichiers statiques de l'administration
    location /media {
        root /usr/lib/python2.5/site-packages/django/contrib/admin/media;
    }

   # quelques fichiers statiques liés à l'application (css, images, js)
    location /static {
        root /home/bar/project_foo;
    }
}

L’adresse du socket peut est connue via la méthode suivante :

$RUNFILES_PATH : définie dans /etc/init.d/django_fastcgi
$PROJECT_PATH : correspond à l’adresse du projet dans laquelle on a remplacé les « / » par des « _ »
l’adresse du socket est : $RUNFILES_PATH/$PROJECT_PATH.socket

Une fonction très basique en bash permet d’automatiser la douloureuse et complexe conversion de chemin :

# elle prend en paramètre le path à convertir, et si aucun paramètre n'est fourni elle utilise le répertoire courant
fastcgi_sockfile() {
    if [ "$1" = "" ]; then
        SITE=`pwd`
    else
        SITE=$1
    fi

    echo "/tmp/`echo $SITE | sed -e 's#/#_#g'`.sock"
}

Installer Redmine sous Nginx

Kévin G. — Sun, 18 Jul 2010 12:10:19 +0000

Ayant eu envie de me la jouer geek, j’ai très récemment remplacé mon Apache par le très bon Nginx. Enfin, quand je dis « remplacé », ce n’est pas exactement vrai, voyez plutôt :

Comme le montre le schéma ci-dessus, toutes les requêtes arrivant sur le serveur sont transmises à Nginx qui va ensuite décider en fonction de leur type s’il va les traiter ou pas. Apache n’est donc plus là que pour traiter les pages PHP, et Mongrel s’occupe quant à lui du Ruby.

Bon, maintenant que vous savez comment mon serveur marche sous le capot, je vais vous expliquer comment mettre en place la partie Nginx + Mongrel, dans l’optique de faire tourner Redmine derrière tout ça.

Je suppose que vous avez un Nginx opérationnel et Ubuntu 10.4 (version serveur ou pas, peu importe), en sachant que les manipulations devraient être sensiblement les mêmes sur les autres dérivés de Debian et sur Debian elle-même.

Installation des .deb

Notre OS fourni des .deb de Mongrel ET de Redmine, donc autant les utiliser :

sudo aptitude install redmine redmine-mysql mongrel

La seule « difficulté » ici étant de correctement renseigner les logins de base de données, je pars du principe que vous saurez vous débrouiller sans moi =3

Automatisation du lancement de Redmine

L’installation des .deb de Redmine et de Mongrel ne nous donne aucun moyen de gérer automatiquement le lancement et l’arrêt de Redmine. Qu’à cela ne tienne, nous allons créer notre propre /etc/init.d/redmine pour gérer tout ça !

#!/bin/sh
set -e

REDMINE_PATH=/usr/share/redmine/
REDMINE_PID=/tmp/mongrel.pid
REDMINE_LOG=/tmp/mongrel.log
REDMINE_PORT=3000

if [ -x /usr/bin/mongrel_rails ] ; then
    HAVE_MONGREL=1
else
    echo "Mongrel not installed."
    exit 0
fi

. /lib/lsb/init-functions

case "$1" in
  start)
    log_action_begin_msg "Starting Redmine server"
    mongrel_rails start -c $REDMINE_PATH -d -e production -p $REDMINE_PORT -P $REDMINE_PID -l $REDMINE_LOG
    log_action_end_msg $?
    ;;
  stop)
    log_action_begin_msg "Stopping Redmine server"
    mongrel_rails stop -c $REDMINE_PATH -P $REDMINE_PID
    log_action_end_msg $?
    ;;
  force-reload|restart)
    $0 stop
    $0 start
    ;;
  *)
    echo "Usage: /etc/init.d/redmine {start|stop|restart|force-reload}"
    exit 1
    ;;
esac

exit 0

Sans oublier de rendre le script exécutable :

sudo chmod +x /etc/init.d/redmine

On peut aussi faire en sorte que Redmine soit automatiquement lancé dès le boot du serveur via un :

sudo update-rc.d redmine defaults

Configuration de Nginx

On dispose maintenant d’un Redmine fonctionnel et théoriquement servi en local par Mongrel, il ne reste donc plus qu’à le rendre accessible depuis l’extérieur. Pour cela nous allons utiliser les fonctionnalités de proxy de Nginx comme le fait le virtualhost suivant :

# redmine.kevingomez.fr
server {
    listen      80;
    server_name redmine.kevingomez.fr;

    location / {
        root /usr/share/redmine/public;
        
        # le port 3000 est celui indiqué dans le fichier /etc/init.d/redmine
        proxy_pass http://127.0.0.1:3000;
    }
}

Notez qu’ici on configure Redmine pour être accessible via un domaine. Si Redmine est dans un sous-répertoire, veillez à ajouter la ligne suivante à la fin du fichier /usr/share/redmine/config/environment.rb :

ActionController::AbstractRequest.relative_url_root = "/redmine"

Autres pistes possibles

Le Redmine étant ici destiné à être utilisé par peu de personnes (pas plus de 4 ou 5), Mongrel devrait se la couler douce un moment.

Si vous souhaitez accueillir un peu plus de monde que moi sur votre installation, je vous suggère de vous documenter sur mongrel_cluster (Nginx sert en fait de load balancer sur plusieurs serveurs Mongrel)

Il est aussi possible d’utiliser Redmine non pas dans un cluster de serveurs Mongrel, mais dans un cluster de serveurs Thin.

Dernière petite piste : Phusion Passenger.

Joe Satriani – Redshift Riders

Kévin G. — Fri, 11 Jun 2010 21:07:37 +0000

Divarvel m’ayant récemment fait découvrir ce dieu qu’est Satriani, je profite de mon blog afin de ramener les quelques brebis égarées ne connaissant pas le talent de ce guitariste sur le droit chemin.

On commence d’ailleurs tout de suite avec Redshift Riders :

Et voici Crowd Chant, parce que c’est du génial, fabuleux et presque jouissif.

Et pour terminer on se fait un petit Surfing With The Alien.

N’est-ce pas que ça fait du bien ?

Un peu de moi

Kévin G. — Tue, 02 Mar 2010 23:01:25 +0000

Rassurez vous, malgré ce titre quelque peu … tendancieux dira-t-on, je ne me livrerai pas dans cet article aux proxénètes de passage sur le net. Non, je laisse les utilisateurs de chatroulette.com s’occuper de ça.

J’en profiterai par contre pour vous donner des informations sur ce qui fait mon quotidien à présent, point de vue informatique j’entends. Car ouais, le fait que je sois en première année de DUT (et qu’en plus je ne m’en sorte pas trop mal … hahaha) n’implique pas que je me la coule douce, c’est même le contraire.
Si vous suivez mes repos Bitbucket par exemple, vous avez pu voir que j’en ai créé trois nouveaux :

php_url_dispatcher :: pour faire court, c’est une class de gestion d’URL rewriting reprenant le principe de celle de Django (possibilité de lier une ou plusieurs URLs à un fichier à inclure/exécuter ou à un callback)
class_upload :: yet another upload class, sauf que celle-ci elle rox.
jPdT :: sur une idée originale de Divarvel, jPdT est un script python capable de générer du code Java et le diagramme des class UML correspondant, et ce en se basant sur le contenu d’un fichier Yaml décrivant les class à construire.
Je n’ai pas été claire dans ma phrase précédente, j’en ai parfaitement conscience et j’ai pourtant la flemme de la remanier. Qu’à cela ne tienne, je n’ai qu’à vous rediriger vers le wiki de jPdT !

À côté de tout ça, je suis en train d’entièrement recoder mon portfolio. Il va roxer, puis son contenu aussi parce que d’ici que j’ai le temps de le finir, j’aurai des tonnes de trucs en tout genre à y mettre.

Autre news : la migration de l’intégralité de mes sites de mon hébergement mutualisé Dinhosting vers un VPS loué sur TonBnc.fr (que je ne peux que recommander !). Vous aurez peut-être remarqué que l’adresse du blog à changé … classe non ?

Et puis ouais, j’ai comme on dit gardé le meilleur pour la fin : je suis, pour 6 mois et en plus des cours de l’IUT, en stage chez EklaBlog/EklaWeb. Et ça, ça roxx carrément !
Je vous passerai les détails ce soir, mais sachez qu’on a pas mal de trucs sympas à dév et que je vous en parlerai certainement incessamment sous peu