theClimber

Nos ordinateurs stockent de plus en plus de choses, les disques durs sont de plus en plus grand ... mais leurs performances ne sont pas toujours au rendez-vous par rapport à l'évolution des autres ressources tels que les processeurs qui sont de plus en plus rapide. De plus en plus de gens s'orientent donc vers des disques durs de type SSD (solid state drive) comme moi.

Mais avoir un ssd c'est aussi un choix contraignant car à capacité égale, un disque classique sera parfois 10 fois moins cher qu'un disque ssd. Donc on a plus tendance à s'orienter vers des disques plus petits et à avoir un disque réseau pour stocker les données moins souvent utilisées. J'ai donc investi dans un petit serveur NAS (serveur de stockage) chez Seagate dont je suis très content. Voyons donc comment le configurer sur linux.

Premièrement assurez-vous d'avoir installé cifs et smbfs:

sudo apt-get install cifs-utils smbfs

Ensuite la manipulation est assez simple. Créez dans le répertoire /mnt (ou ailleurs en fonction de vos préférences) les différents partages que vous avez configuré sur votre NAS

sudo mkdir /mnt/share1
sudo mkdir /mnt/share2

Il ne reste plus qu'à configurer le système à monter (lier) votre disque réseau à cet emplacement à chaque démarrage. Pour ce faire, modifiez votre fichier /etc/fstab en ajoutant les deux lignes suivantes (adaptez en fonction de vos besoins)

# configure NAS
//IP_SERVEUR/SHARE1 /mnt/share1 smbfs username=VOTREUSER,password=VOTREPASSWD,uid=1000,gid=1000 0 0
//IP_SERVEUR/SHARE2 /mnt/share2 smbfs username=VOTREUSER,password=VOTREPASSWD,uid=1000,gid=1000 0 0

Pour illustrer avec un cas concret, imaginons les configurations suivantes :

• IP_SERVEUR = 192.168.0.10
• VOTREUSER = greg
• VOTREPASSWD = mon_super_mot_de_passe

# configure NAS
//192.168.0.10/share1 /mnt/share1 smbfs username=greg,password=mon_super_mot_de_passe,uid=1000,gid=1000 0 0
//192.168.0.10/share2 /mnt/share2 smbfs username=greg,password=mon_super_mot_de_passe,uid=1000,gid=1000 0 0

Comment voir si ça fonctionne? Essayez de monter le répertoire manuellement :

sudo mount /mnt/share1

Si vous n'avez pas d'erreurs, allez voir dans le répertoire et normalement vous devriez y retrouver les fichiers que vous y avez déposé avant. C'est que la connexion est bien établie.

Maintenant redémarrez votre ordinateur, et à chaque démarrage les répertoires seront montés lorsque vous serez dans votre réseau local (évidement si vous n'êtes pas dans votre réseau local, le serveur NAS ne sera pas accessible.

Une fois une application crée, une fois un thème réalisé, on est heureux de pouvoir en faire profiter tout le monde. Seulement voilà, tout le monde ne parle pas la même langue que nous. Donc si nous souhaitons distribuer notre thème à plus grande échelle il est évident qu'une internationalisation (i18n ou l10n) du thème sera nécessaire. Les développeurs d'applications web PHP connaissent bien ce problème et il est maintenant courant d'utiliser gettext pour gérer les différentes langues dans une application.

Ceci dit, une fois le thème crée, ça n'est pas toujours évident d'en extraire le texte pour créer un support gettext qui permet une traduction facile dans plusieurs langues. C'est donc en travaillant sur le Bilboplanet que je me suis confronté à cette difficulté. Mon but était de rendre l'application la plus générique possible : et donc traduisible en fonction des besoins. Extraire les strings de mon application à la main aurait été impossible ... d'autant plus que je modifie souvent mon code et il serait impensable de garder ma liste de traductions à jour. J'avais donc besoin d'un outil automatique.

J'ai donc mis en place un petit script d'extraction de strings automatique pour le moteur de templates Hyla TPL (qui est compatible avec PHP Lib) pour générer les fichiers .po dont j'avais besoin. Le code est disponible ici :

export_tpl-v1.0.py

La fonction à appeler pour lancer la génération du fichier gettext est la fonction "extract_tpl(tpldir)" à laquelle vous devez passer en paramètre le chemin vers votre répertoire de thème. La fonction ira automatiquement chercher le fichier "index.tpl" et suivra les liens internes du type "include" pour que tous les fichiers inclus soient aussi traduits. Le résultat est un fichier .po que vous pouvez ensuite traduire à votre guise :

def extract_tpl(tpldir):
	translate = Translation(tpldir)

	if os.path.isfile(os.path.join(os.path.abspath(tpldir), 'index.tpl')):
		translate.extract_from_tpl('', 'index.tpl')
	else:
		translate.extract_tpl()
	
	potcontent = translate.gettext_code()

	print potcontent

Pour ceux qui n'y connaissent rien en python mais qui souhaiteraient quand même tester ce script. Je vous invite à installer python et ipython chez vous. Puis dans le répertoire dans lequel se trouve le fichier python ci-dessus, faites :

greg@gsat:~/Desktop$ ls export_tpl.py 
export_tpl.py
greg@gsat:~/Desktop$ ipython
Python 2.6.6 (r266:84292, Sep 15 2010, 16:22:56) 
Type "copyright", "credits" or "license" for more information.

IPython 0.10 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object'. ?object also works, ?? prints more.

In [1]: from export_tpl import *

In [2]: extract_tpl('/home/greg/Public/bilboplanet/themes/gil-galad/')

Ca fait aujourd'hui un certain bout de temps que je n'ai plus mis à jour ce blog. C'est l'occasion donc de vous partager ce petit script qui m'a occupé pendant un dimanche après-midi d'hiver quand je m'embêtais ... Je m'étais pris la tête sur un problème la veille au soir, et je m'étais juré d'essayer de trouver une solution la plus optimale possible pour le régler.

Je vais donc essayer de vous expliquer le problème de la manière la plus simple qui soit. C'est d'ailleurs un problème que vous avez surement déjà rencontré dans votre vie de tous les jours. C'est hyper basique, mais on ne se rend pas toujours compte qu'il cache quand même un peu de subtilité (comme quoi, quand on est geek on peut s'occuper avec très peu )

Lorsque vous êtes en vacances avec des amis et que vous demandez à chacun de tenir ses comptes, vient la fin des vacances où il faut évidement équilibrer les comptes. Alors tant qu'on n'est pas parti à plus de 4 en vacances c'est en général encore le genre de calculs abordables à conditions que les comptes ont bien été tenus, mais lorsque le nombre de participants augmente, la complexité du problème augmente de manière exponentielle pour notre petit cerveau. En effet, notre bon sens voudrait optimiser le nombre de remboursements pour se "faciliter" la vie, mais on se rend vite compte que cette optimisation est compliquée.

C'est l'autre jour en passant la soirée à bouffer des brochettes et à boire quelques bieres autour d'un feu de camp avant une nuit à la belle étoile qu'on a discuté de ce problème avec un ami qui est le fondateur de tricount (que vous connaissez surement, et si vous ne connaissez pas, utilisez le, c'est vraiment bien) Il semblait me dire que le problème est difficilement scalable lorsque le nombre de participants augmente de manière drastique.

Prennons un exemple pour illustrer le problème : Nous sommes partis en vacances à 4 et à la fin des vacances nous obtenons le résultat suivant :

• Tom a dépensé 10 EUR
• Bob a dépensé 100 EUR
• Guy a dépensé 70 EUR
• Val a dépensé 20 EUR

En total, on a dépensé 200 EUR. Donc chacun aurait du dépenser 50 EUR. Pour ré-équilibrer exprimons ça sous forme de compte (ceux qui sont en négatif doivent de l'argent, ceux qui sont en positif doivent recevoir de l'argent) :

• Tom : -40 EUR
• Bob : 50 EUR
• Guy : 20 EUR
• Val : -30 EUR

On voit désormais clairement que pour optimiser le nombre de transactions pour le remboursement, il faut chipoter un peu, et plusieurs solutions sont possibles : Solution 1 :

• Tom rembourse 40 EUR à Bob
• Val rembourse 20 EUR à Guy
• Val rembourse 10 EUR à Bob

Solution 2 :

• Tom rembourse 20 EUR à Guy
• Tom rembourse 20 EUR à Bob
• Val rembourse 30 EUR à Bob

Dans ce cas ci les 2 solutions proposent un nombre de transactions similaires. Mais ça n'est pas toujours le cas. De plus, si on voulait optimiser ce choix, qu'est-ce qui nous ferais choisir pour la solution 1 ou la solution 2?

Et si le nombre de participants était de X ... est-ce que le problème ne serait pas encore plus complexe?

J'ai donc essayé d'écrire un petit algorithme qui propose une solution. Qu'on pourrait peut-être améliorer. Je vous invite à vous pencher sur la question aussi :

Tant que tous les comptes ne sont pas à 0 :
    Pour tous les comptes :
        si on trouve deux comptes dont la somme fait 0
        alors on les annule et on compte une transaction
    X = celui qui doit le plus d'argent
    Y = celui a qui on doit le plus d'argent
    X rembourse un maximum a Y
    on compte une transation

Je suis sur que cet algorithme peut encore être amélioré ! En ce moment j'ai des performances en O(n) au niveau de mon petit script python que vous pourrez lire ci-dessous. Je suis toujours intéressé par les solutions plus optimales (après tout, je n'ai que passé quelques heures sur le problème)

• En abscisse vous avez le nombre de personnes impliquées dans les comptes (donc le nombre de comptes)
• En ordonnée vous avez le nombre de transactions nécessaires avec mon algo

On arrive plus ou moins à n/2 + delta transactions, avec n qui est le nombre de participants et delta qui tend vers 0 quand n tend vers l'infini

Vous pouvez télécharger le script python ici : transactions.py

Des plus grosses installations aux plus petites, le monitoring du réseau reste un problème bien présent pour pouvoir garder un oeil permanent sur les installations et pouvoir réagir au plus vite en cas de problème. La solution la plus souvent utilisée n'est plus à présenter. Tout le monde connait aujourd'hui le moteur de monitoring réseau open-source mieux connu sous le nom de Nagios.

Mais comme ça marche? Pour ce qui est de l'installation et de la configuration d'un serveur Nagios, je vous renvoie vers d'autres très bon tutoriels détaillés comme ceux de Nicolargo. Mais une fois le serveur installé, on veux pouvoir monitorer tous les ordinateurs d'un même réseau. Voici un petit tutorial pour vous expliquer comment configurer un ordinateur de votre réseau pour qu'il puisse être monitoré par votre serveur Nagios. (Ce tutoriel vaut pour les Linux Debian-like, pour les autres distributions, ça sera similaire, mais surement pas identique).

I love OpenOffice.org, and have been using it for years. One of the benefits is the sheer amount of space that one can save when using OpenOffice Writer - the ODT files are much smaller. In an age where hard drives and other storage doesn't limit the size of files as much, it seems I am a dinosaur for even considering the amount of bytes I can save. Still, the more free space I have, the more I can store. Plus, when it comes to sending and receiving documents, the smaller they are the less impact it is on a network. In the grand scheme of things, I think bloated documents are as bad as low bandwidth in some areas.

This benefit of OpenOffice.org is lost when I have to send someone a Microsoft Office format for a text file. It bugs me, and I often forget to wipe the converted files to save space - maybe I am getting old. Thus, when I came across How to open ODT (openoffice.org text) files in Microsoft Word, I was surprised and happy.

Quoting from the original site:

Office 2007

1. Install Service Pack 1 for Office 2007.
2. Install Sun ODF Plugin for Microsoft Office.
3. Open ODT document via File > Open, or by double-clicking the ODT file and when prompted for the application to open it with, choose Word.

If you have Office 2003, installing the Sun ODF Plugin should just work.

If you don’t have administrator privileges to install software, you can try an online converter such as Zamzar or Media Convert. You can also upload ODT documents to Google Docs or Zoho Writer.

Thank you. Now, when I accidentally send a smaller file and am short on time, I can simply point people to that and allow me to stop converting files because Microsoft itself had never supported ODT - an open standard with open source software that they could easily have allowed for to be intercompatible.