Auteur/autrice : nicolargo

Créateur de blog de Nicolargo, je suis un partisan des logiciels libres et un passionné des nouvelles technologies.

Mon desktop 201012

Auteur de l’article Par nicolargo
Date de l’article 01/12/2010
9 commentaires sur Mon desktop 201012

On attaque le dernier mois de 2010 avec, comme chaque mois, un nouveau desktop (sous Ubuntu 10.10) qui va m’accompagner jusqu’à la nouvelle année !

Voilà ce que cela donne:

Fond d’écran: Sleepless nights
GTK: Look des fenêtre Equinox + icônes Faenza
Sur ce bureau: Docky + Terminator + Nautilus Elementary

Installation des dépôts

On lance un terminal et on saisie les lignes de commandes suivantes:

sudo add-apt-repository ppa:tiheum/equinox

sudo add-apt-repository ppa:am-monkeyd/nautilus-elementary-ppa

sudo aptitude update

sudo aptitude safe-upgrade

Installer de la combo magique (Equinox + Faenza + Nautilus Elementary)

Je n’ai pas trouvé mieux à mon goût pour le moment. Equinox est clair, les icônes Faenza sont lisibles et facile à reconnaître et Elementary apporte une certaine légèreté à Nautilus.:

sudo aptitude install gtk2-engines-equinox equinox-theme equinox-ubuntu-theme faenza-icon-theme

nautilus -q

On active le tout en allant dans le menu “Système > Préférences > Apparences > Thème > Equinox Evolution“.

Installation de Docky

Ce dock « à la MacOS X » est disponible dans les dépôt standard, pour l’installer en ligne de commande:

sudo aptitude install docky

Pour le paramétrage, j’utilise:

Voilà ce que j’ai dedant au moment de l’écriture de ce billet:

Paramétrage de mon tableau de bord

J’utilise l’application NetSpeed pour voir en temps réel les débits sur mon interface réseau. Il faut l’installer avec la ligne de commande suivante:

sudo aptitude install netspeed

Ensuite je configure de la manière suivante:

Et vous cela donne quoi vos desktops en ce moment, à vos screenshots !

Étiquettes desktop, gnome, linux, ubuntu

Open-source Reseau Systeme

Utilisation du protocole NFS avec votre NAS

Auteur de l’article Par nicolargo
Date de l’article 28/11/2010
18 commentaires sur Utilisation du protocole NFS avec votre NAS

J’ai un NAS Synology DS110+ chez moi pour sauvegarder mes données et comme de serveur DLNA vers ma télévision.

Depuis le début j’avais utilisé le protocole réseau SMB (aka CIFS), installé et configuré par défaut sur le NAS.

Comme je n’étais pas satisfait des performances et de l’intégration de ce protocole sur ma distribution Ubuntu, j’ai décidé d’activer un protocole issu du monde Unix: j’ai nommé NFS.

Activation de NFS sur le NAS Synology DS110+

C’est assez simple en se connectant sur l’interface d’administration Web DSM:

Configuration de Linux comme client NFS

Sous une distribution Debian ou Ubuntu, il suffit d’installer le paquet autofs. Celui-ci prendra en charge nativement le protocole NFS:

sudo aptitude install autofs

Ensuite il faut éditer les deux fichiers suivants:

/etc/auto.master

/media/nas /etc/auto.nfs –ghost,–timeout=60

Ce fichier permet de définir dans quel répertoire de votre machine client GNU/Linux les répertoires partagés par votre NAS seront présentés (/media/nas dans mon cas).

/etc/auto.nfs

video -fstype=nfs,rw,intr 192.168.0.253:/volume1/video

Dans ce second fichier, on défini la liste des répertoires partagés (un répertoire par ligne). Par exemple, nous allons « mounter » le répertoire NFS /volume1/video du serveur NAS (adresse IP 192.168.0.253) vers le répertoir /media/nas/video de notre machine client GNU/Linux.

On relance ensuite le daemon autofs pour prendre en compte ces deux fichiers de configuration:

sudo service autofs restart

A partir de ce moment là, à partir du moment ou vous utiliserez le répertoire /media/nas/video, un montage sera automatiquement effectué vers votre serveur NAS et les fichiers seront visibles localement.

Et au niveau des performances

Outre une intégration parfaite à Linux, j’ai observé un gain non négligeable des performances notamment lors des phases d’écritures de fichiers sur le serveur NAS.

Sources pour la rédacion ce billet:

Étiquettes linux, nfs, synology, ubuntu

Open-source Planet-libre Web

Mon menu best-of des comptes Twitter sur l’open-source

Auteur de l’article Par nicolargo
Date de l’article 26/11/2010
8 commentaires sur Mon menu best-of des comptes Twitter sur l’open-source

Avant le weekend, quelques comptes Twitter que j’emporterai sur une île déserte pour me tenir informé de l’actualité des logiciels open-source !

@cyrilleborne Cyrille BORNE

Même ta bio faut que tu la fasses en 140 caractères, c’est bien twitter , bientôt mon épitaphe en 30, tiens je vois bien il était vieux il utilisait Mandriva

@WebUpd8 WebUpd8 -Ubuntu blog

Linux & Ubuntu & Open Source and web design.

@Omgubuntu OMG! UBUNTU!

Everything Ubuntu. Daily.

@pscoffoni Philippe Scoffoni

Logiciels Libres, Open Source, technologies ouvertes, Cloud Computing et tout le reste…

@nitot Tristan Nitot

Mozilla Europe founder. Free Software, Open Web evangelist

@tuxplanet Tux-planet – Linux

Linux, Free software, Open Source, Logiciels Libres, Ubuntu, Fedora, Français, France, French

@pydubreucq Pierre-Yves Dubreucq

Admin-Sys et Passionné de logiciels libres, je tiens un blog consacré aux logiciels libres, membre de l’April,Chtinux et de TuxFamily.org Modo du Planet-Libre

A vous de nous faire découvrir vos comptes Twitter ou Identi.ca dans le domaine du libre !

Étiquettes libre, Open-source, twitter

Nagios Open-source Planet-libre Reseau

Utiliser Nmap pour générer vos fichiers de configuration Nagios

Auteur de l’article Par nicolargo
Date de l’article 25/11/2010
76 commentaires sur Utiliser Nmap pour générer vos fichiers de configuration Nagios

ATTENTION: Dans sa version actuelle, le script ne marche qu’avec la version 5 de Nmap. Sinon, le fichier .cfg généré risque de rester désespérément vide…

Renseigner des fichiers de configuration de Nagios « à la mimine » n’est pas une activité que je juge passionnante.

Nous allons voir dans ce billet comment utiliser le scanner de réseau Nmap pour nous aider dans cette lourde tache en développant un petit Script Shell nommé nmaptonagios.sh. Pour les plus impatients, vous pouvez directement aller au dernier chapitre de ce billet pour voir comment installer et lancer le script.

Avant de commencer

Le plus simple est de faire cette découverte du réseau directement depuis votre serveur de supervision hébérgeant Nagios. En effet, les éventuels mécanismes de filtrage de votre réseau doivent déjà permettre a ce serveur de faire des ping et des requêtes TCP/UDP vers l’ensemble des machines (ou alors votre serveur Nagios ne doit pas bien fonctionner…).

Il faut commencer par installer NMap sur cette machine.

Installation de Nmap sous Ubuntu / Debian:

aptitude install nmap

Récupérer la liste des machine « UP » de votre réseau

Dans la suite de ce billet, je prendrai l’exemple d’un adminsitrateur réseau qui veut découvrir les machines de son LAN qui utilise la plage d’adresse IP suivante: 192.168.1.0/24.

Pour avoir une liste des adresses ou des noms (si vous avez un serveur DNS à jour) des machines répondant aux PING de votre réseau, il suffit de saisir la commande:

nmap -sP 192.168.1.0/24

Si un nom d’hôte est associé à une adresse il est affiché.

Exemple:

Nmap scan report for 192.168.1.104

Host is up (0.0019s latency).

Nmap scan report for labo-desktop2 (192.168.1.109)

Host is up (0.00056s latency).

Cette première commande va nous servir pour générer la boucle principale de notre script.

Détection des OS

Pour générer dans la configuration de Nagios une description des hôtes contenant l’OS, nous allons utiliser l’option -O de nmap:

nmap -O 192.168.1.109

Selon le système d’exploitation la détection se fait de manière plus au moins simple.

3 lignes sont intéressantes dans le rapport généré par l’option -O:

OS Detail: ***

Running: ***

Service detail: ***

Notre script va donc tester ces variables puis choisir celle qui donne une information la plus précise (sachant que ce test n’est pas fiable à 100%).

Détection des services

On entre dans le vifs du sujet avec la détection des services accessibles sur les machines.

On filtre pour cela les ports TCP ou UDP ouverts (open), puis on vérifie qu’un plugin est disponible dans le répertoire /usr/lib/nagios/plugins (il est possible de changer ce répertoire en modifiant la variable NAGIOS_PLUGINS_PATH au début du script).

Par exemple, si le script détecte que le port TCP/80 (http) est open, alors il va rechercher le plugin /usr/lib/nagios/plugins/check_http et configurer le service correspondant. Si il ne le trouve pas il va se rabattre sur un check_tcp simple sur le port 80.

On utilise la commande nmap suivante:

nmap -sV 192.168.1.109

Installation et utilisation du script nmaptonagios.pl

On commence par récupérer le script:

wget https://raw.github.com/nicolargo/nagiosautoinstall/master/nmaptonagios.sh

chmod a+x ./nmaptonagios.sh

Puis on l’exécute:

sudo ./nmaptonagios.sh 192.168.1.0/24

…

—————————————————————

Nagios configuration file: /tmp/nmaptonagios-20101124095216.cfg

—————————————————————

A la fin du script, on a un fichier de configuration de Nagios à éditer et à adapter à vos besoins:

vi /tmp/nmaptonagios-20101124095216.cfg

Pour faire prendre en compte ce fichier par Nagios, il suffit de le copier dans le répertoire /usr/local/nagios/etc/objects:

sudo cp /tmp/nmaptonagios-20101124095216.cfg /usr/local/nagios/etc/objects

sudo chown nagios:nagios /usr/local/nagios/etc/objects/nmaptonagios-20101124095216.cfg

Puis de relancer nagios:

sudo service nagios restart

Le script est distribué sous licence GPL v2. Libre à vous de l’adapter, modifier, copier et distribuer !

Étiquettes nagios, nmap

Nagios Open-source Planet-libre Web

Notification Twitter (oAuth) dans Nagios

Auteur de l’article Par nicolargo
Date de l’article 23/11/2010
7 commentaires sur Notification Twitter (oAuth) dans Nagios

Twitter est un service devenu indispensable pour la veille technologique des geeks que nous sommes. Son « ouverture via des API permet également de l’utiliser comme un moyen simple de diffusion d’informations de type alerte.

Nous allons dans ce billet voir comment configurer Nagios (l’outil de supervision open-source) pour envoyer des alertes sur un compte Twitter dédié. La méthode détaillé est compatible avec la nouvelle méthode d’authentification de Twitter nommée oAuth.

Avant de commencer

Pour ne pas poluer votre time-line pricipale, je vous conseille de créer un compte Twitter dédié à ce besoin. C’est sur ce dernier que les alertes seront envoyées. Il suffira ensuite aux « administateurs » de suivre ce compte Twitter pour être informé au plus vite des anomalies survenues sur le réseau.

Pour créer notre compte Twitter special Nagios, on va à l’adresse suivante:

Il faut bien retenir votre « username » (nagiosnicolargo dans mon cas) et « password ».

Il faut ensuite se rendre dans les « Settings » et cliquer sur le bouton « Protect my updates » pour forcer l’approbation des utilisateurs qui vont pouvoir suivre ce compte Twitter. Quand un des administrateurs fera une demande pour suivre ce compte Twitter, il faudra l’approuver. Cela évite que n’importe qui voit que votre réseau est tombé :)…

Installation du script de mise à jour de Twitter

Depuis que l’authentification sur Twitter, la procédure est un peu plus compliquée. J’ai donc écrit un billet spécifique sur le sujet. Il suffit de suivre cette procédure en prenant comme compte Twitter le compte préalablement créé dans le chapitre précédant pour y associer une nouvelle application (le script Python nommé tweetitcli.py) qui va permettre à Nagios de mettre à jour la timeline.

Après cette étape, vous devez donc être capable de mettre à jour la timeline de votre compte Twitter dédié avec une ligne de commande du type:

./tweetitcli.py ‘Petit test depuis la ligne de commande Linux’

Je vous laisse vérifier que cela marche…

Il faut ensuite copier le script en question dans le répertoire des plugins de Nagios:

cp ./tweetitcli.py /usr/local/nagios/libexec/

sudo chown nagios:nagios /usr/local/nagios/libexec/tweetitcli.py

Configuration du serveur Nagios

Passons maintenant aux fichiers de configuration de Nagios. Je pars sur le principe que vous avez un serveur Nagios en état de marche. On commence par ajouter la commande tweetitcli.py qui va permettre d’envoyer un message à notre compte Twitter via Curl:

# vi /usr/local/nagios/etc/objects/commands.cfg

define command{
command_name notify-host-by-twitter
command_line $USER1$/tweetitcli.py « $HOSTNAME$ is $HOSTSTATE$ »
}
define command{
command_name notify-service-by-twitter
command_line $USER1$/tweetitcli.py « $SERVICEDESC$@$HOSTNAME$ is $SERVICESTATE$ ** $SERVICEOUTPUT$ »
}

Ensuite on défini le contact (ou le groupe à vous de voir):

# vi /usr/local/nagios/etc/objects/templates.cfg

define contact{
name nicolargoadmin
alias Admin Nicolargo
service_notification_period     24×7
host_notification_period        24×7
service_notification_options    w,u,c,r,f,s
host_notification_options       d,u,r,f,s
service_notification_commands   notify-service-by-twitter
host_notification_commands      notify-host-by-twitter
}

Puis enfin on associe le contact avec le service à surveiller (par exemple que mon serveur Web tourne bien…):

define host{
use                     linux-host
host_name               gandiserveur
alias                   Serveur Gandi
address                 blog.nicolargo.com
parents                 monrouteur
hostgroups              prj-perso
contacts                nicolargoadmin
}
define service{
use                     generic-service
host_name               gandiserveur
service_description     HTTP
check_command           check_http
contacts                nicolargoadmin
}

On teste…

Il ne reste plus qu’a tester vos fichiers de configuration:

sudo /usr/local/nagios/bin/nagios -v /usr/local/nagios/etc/nagios.cfg

et à relancer Nagios:

sudo service nagios restart

A chaque notification, un nouveau message devrait apparaître dans votre compte Twitter dédié 😉

Étiquettes icinga, nagios, oauth, twitter

Nagios Open-source Planet-libre Web

Twitter en ligne de commande (même avec oAuth)

Auteur de l’article Par nicolargo
Date de l’article 22/11/2010
23 commentaires sur Twitter en ligne de commande (même avec oAuth)

Il y a quelque temps, j’avais écrit un billet sur comment envoyer les alertes de votre serveur Nagios sur un compte Twitter (ou comment réunir les SI et le Web 2.0). Malheureusement, depuis cette date, Twitter a changé la méthode d’authentification pour poster des tweets. Ce n’est plus une authentification HTTP classique (qui pouvait donc être facilement faite en ligne de commande avec curl par exemple) mais une authentification oAuth, beaucoup plus souple mais nettement plus complexe.

Nous allons donc dans ce nouveau billet voir comment mettre en place l’authentification oAuth pour un script Python qui permettra à partir d’une simple ligne de commande de mettre à jour une timeline Twitter.

A vos fourneaux !

Les ingrédients…

Pour suivre cette recette il faut:

un compte Twitter
la librairie Python python-tweepy
un navigateur Web (pour enregistrer votre application)

Installation de Python-tweepy

Cette librairie Python va vous permettre de parler oAuth avec le serveur Twitter. Il existe un PPA pour Ubuntu (pour les autres distribution GNU/Linux, il faut installer la bête en suivant ces instructions):

sudo add-apt-repository ppa:chris-lea/python-tweepy

sudo aptitude update && sudo aptitude install python-tweepy

Update: Sous Debian la procédure à suivre est la suivante (merci Benjamin):

apt-get install python python-setuptools python-json python-twitter

wget http://pypi.python.org/packages/source/t/tweepy/tweepy-1.7.1.tar.gz

tar xvfz tweepy-1.7.1.tar.gz

cd tweepy-1.7.1

python ./setup.py install

Enregistrement de votre script

C’est la première étape: déclarer votre application (votre script) sur le serveur Twitter. Dans la suite de ce billet je vais procéder à l’enregistrement d’une application qui s’appellera ‘tweetit’ (c’est le nom de mon script en ligne de commande qui permettra de mettre à jour ma Timeline).

Pour cela, il faut se rendre à l’URL suivante: http://twitter.com/oauth_clients

Puis cliquer sur Register a new application »

On saisie ensuite le formulaire:

Une fois le formulaire validée, vous devriez être redirigé vers une page contenant deux informations importantes: Consumer key (la clés) et Consumer secret (le mot de passe) de votre application.

Il faut bien sur mettre ces informations de coté.

Connecter votre script à votre compte Twitter

Nous allons utiliser la librairie python-tweepy pour faire cette étape qui ne devra être faite qu’une seule fois lors du développement de votre application.

Le plus simple est de reprendre le script écrit par Jeff Miller sur son blog. On va donc créer un script nommé tweetit-register.py contenant le code suivant (remplacer les codes):

#!/usr/bin/env python

import tweepy

CONSUMER_KEY = ‘VOTRE CODE CONSUMER KEY’

CONSUMER_SECRET = ‘VOTRE CODE CONSUMER SECRET’

auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)

auth_url = auth.get_authorization_url()

print ‘Please authorize: ‘ + auth_url

verifier = raw_input(‘PIN: ‘).strip()

auth.get_access_token(verifier)

print « ACCESS_KEY = ‘%s' » % auth.access_token.key

print « ACCESS_SECRET = ‘%s' » % auth.access_token.secret

On exécute le script:

chmod a+x tweetit-register.py

./tweetit-register.py

Le script va vous afficher une URL et attendre un code PIN:

Please authorize: http://twitter.com/oauth/authorize?oauth_token=Ndddb0DBsjd6PNYccSEtl8vtdYkNsPRCk5joO7djqO8

PIN:

On copie l’URL dans un navigateur Web:

On récupère ensuite le code PIN que l’on entre dans notre terminal:

PIN: 0665141

On obtient en retour la clés et le mot de passe d’accès :

ACCESS_KEY = ‘7707822-TWzha9rf3icVF1h0FhGnaK5q7iLyNIRzHXDY8aagt4’

ACCESS_SECRET = ‘3dbTcWkU1LIYG4MtwmraausjaoSne5coGbXKOXhDfG0’

Création du script

Voilà (enfin), on peut développer notre application (tweetit.py):

#!/usr/bin/env python

import sys

import tweepy

# Authentification oAuth

CONSUMER_KEY = ‘Consumer Key’

CONSUMER_SECRET = ‘Consumer Secret’

ACCESS_KEY = ‘Access Key’

ACCESS_SECRET = ‘Access Secret’

auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)

auth.set_access_token(ACCESS_KEY, ACCESS_SECRET)

api = tweepy.API(auth)

# Main program

api.update_status(sys.argv[1])

On rend le script executable:

chmod a+x tweetit.py

Test de l’application

On lance le script avec le texte à tweeter:

./tweetitcli.py ‘Petit test depuis la ligne de commande Linux…’

Et voilà le travail:

Et voila, bientôt un prochain billet pour voir comment intégrer ce nouveau script à Nagios 🙂

Source pour la rédaction de cet article:

Jeff Miller Blog

Étiquettes command line, gnu, ligne de commande, linux, oauth, python, twitter

Gstreamer Open-source Planet-libre Video Web

MyScreenCast passe en version 0.11

Auteur de l’article Par nicolargo
Date de l’article 20/11/2010
18 commentaires sur MyScreenCast passe en version 0.11

Il y quelques mois, j’avais écrit un script shell (MyScreenCast) permettant d’automatiser, en ligne de commande, la création d’un screencast (une vidéo de votre écran) avec des outils libres disponibles sur les distributions GNU/Linux (notamment GStreamer).

Je viens de mettre en ligne la version 0.11 de ce script avec les fonctions suivantes:

possibilité d’incruster un texte en overlay avec l’option -o <Bla bla>
encodage du même screencast avec différents codecs
amélioration des pipelines GStreamer

Ces fonctions viennent s’ajouter aux fonctions suivantes:

capture vidéo de l’écran quelque soit sa résolution
capture audio (depuis le microphone par défaut de votre système)
incrustation de la vidéo venant de votre Webcam (avec l’option -w)
affichage des touches actionnées avec keymon (avec l’option -k)

Pour tester ce logiciel, il faut récupérer la dernière version du script:

MyScreencast

Puis de lancer la ligne de commande suivante:

chmod a+x ./myscreencast.sh

./myscreencast.sh

Comme toujours j’attend vos retours / tests sur d’autres distributions (je l’ai testé sous Ubuntu 10.10).

Étiquettes screencast

Gstreamer Open-source Planet-libre Reseau Web

Nagios: vérifier l’existence d’un fichier sur un site Web

Auteur de l’article Par nicolargo
Date de l’article 15/11/2010
16 commentaires sur Nagios: vérifier l’existence d’un fichier sur un site Web

Il y a quelques jours je me suis rendu compte que lors d’une mise à jour de mon blog j’avais oublié de copier le fichier googlexxxxxxxxx.html à la racine de mon site. Ce fichier permet à Google de vérifier que le site est bien associé à mon compte Google Webmaster et au mécanisme de lecture d’un autre fichier important: sitemap.xml. En conséquence, mon site n’était plus référencé dans Google… C’est ici Google Analytics qui m’a servi de serveur de supervision vu que mon trafic a été divisé par 8 :).

Disposant d’un serveur de supervision Nagios pour mes tests, je me suis pencher sur le problème suivant: comment vérifier la présence d’un fichier précis sur un site Web en utilisant le protocole HTTP.

Il n’y a pas de plugin par défaut permettant d’effectuer cette action. Le seul qui se rapproche est check_http. Malheureusement ce dernier permet seulement de vérifier que le serveur Web est opérationnel mais ne fait aucune interprétation sur le contenu du site.

En cherchant un peu on tombe rapidement sur le plugin check_url. Ce dernier, écrit en Perl, utilise Wget pour récupérer le fichier cible et interprète le code d’erreur renvoyé par le serveur Web.

J’ai du un peu modifier le code pour le rendre compatible avec une installation ou le daemon Nagios tourne avec un utilisateur qui n’a pas de « home directory ». Le script modifié est disponible ici.

On a les associations code d’erreur Nagios / code d’erreur HTTP suivantes:

OK = (« 200 »);

WARN = (« 400 », « 401 », « 403 », « 404 », « 408 »);

CRITICAL = (« 500 », « 501 », « 502 », « 503 », « 504 »);

Pour installer le plugin, il faut le copier dans le répertoire /usr/local/nagios/libexec de votre serveur Nagios puis fixer les bons droits:

cd /usr/local/nagios/libexec

sudo wget https://raw.github.com/nicolargo/nagiosautoinstall/master/check_url.pl

sudo chown nagios:nagios /usr/local/nagios/libexec/check_url.pl

sudo chmod a+x /usr/local/nagios/libexec/check_url.pl

Enfin on configure un nouveau service dans le fichier commands.cfg:

# CheckURL

# $ARG1$: URL a tester (exemple: http://blog.nicolargo.com/sitemap.xml)

define command{

command_name check_url

command_line $USER1$/check_url.pl $ARG1$

}

Puis on définie le service associé au site/fichier à vérifier:

# Define a service to check URL

# http://blog.nicolargo.com/sitemap.xml

define service{

use generic-service

host_name monserveur

service_description URL Sitemap

check_command check_url!http://blog.nicolargo.com/sitemap.xml

}

Une fois Nagios relancé, une alerte sera automatiquement remontée si le fichier sitemap.xml n’est pas accessible !

Il est bien sur possible de faire autant d’alertes que de fichiers à vérifier.

Blog Open-source Planet-libre Web

Le blog de Nicolargo a son application IOS

Auteur de l’article Par nicolargo
Date de l’article 14/11/2010
37 commentaires sur Le blog de Nicolargo a son application IOS

Mon ami Nicolas Richasse vient de finaliser la première version de l’application du « Blog de Nicolargo » pour iPhone, iPod et iPad. Cette application est d’ores et déjà téléchargeable gratuitement sur l’Apple Store. (voir ici la page officielle de l’application pour plus d’informations).

Vous devez trouver plutôt causasse le fait que ce blog dispose d’une application pour iPhone (axe du mal propriétaire) plutôt que pour Android (les gentils libristes)…

La raison principale est assez simple. Nicolas Richasse m’a proposé de développer gratuitement cette application pour « se faire la main » sur le développement d’application sous IOS. Disposant d’un iPhone 4 à la maison, je n’ai donc pas hésité longtemps (si une âme généreuse veut faire la même chose sous Android je suis preneur :)).

Cependant notre « bon coté de la force » nous a poussé à réfléchir à un modèle plus en accord avec nos convictions. Après quelques discussions avec lui, nous avons donc décidé de proposer l’application sous licence GPL v2.

Elle sera disponible au téléchargement et librement « adaptable » à votre blog dans quelques temps (sur une forge qu’il nous reste à identifier). Nicolas souhaite juste avoir un peu de temps et de recul sur l’application pour proposer une code documenté et facile à forker pour d’autres blogs sous WordPress..

Il faut donc considérer l’application IOS du Blog de Nicolargo comme une démonstration de ce code open-source.

A télécharger, tester puis commenter sans modération !

Que pensez-vous de cette initiative ?

Etes-vous intéressé pour développer un « fork » de cette application pour votre blog ?

Souhaitez vous participer au développement de l’application « core » pour l’améliorer ?

A vos commentaires…

PS: l’application est bien entendu gratuite. Si vous voulez soutenir Nicolas Richasse dans son développement vous pouvez acheter son application iNumber qui reprend grosso modo la règle des chiffres de l’émission des chiffres et des lettres.