Cela vous arrive aussi à vous de lancer une grosse mise à jour, et de vouloir ensuite la placer dans un screen, ou un tmux ?
Moi ça m'arrive souvent, et jusque maintenant j'avais une solution :
Créer un script qui lance la mise à jour dans un screen.
Etant sur twitter, je suis l'activité de @climagic.
Voici donc son dernier tweet à l'heure actuelle :
@climagic reptyr # reptyr can be used to reattach a program on another tty to the current so you can transfer it into screen/tmux. Thx @d3m0n35
Il s'agit donc du paquet reptyr sous Debian :
Trouvez une formation
# apt-get install reptyr
$ reptyr <PID>
19:06 <xorg62_> WMFS2 dans le master \o/
Non ce n'est pas un fake, la nouvelle version tant attendue de WMFS2 est bien sortie ce lundi 16 janvier !
Qu'apporte-t-elle ? Pourquoi une nouvelle version ?
xorg62 avait décidé il y a quelques mois de reprendre le code de WMFS de 0, afin de repartir sur une base saine, sur une architecture propre. Ayant désormais un cahier des charges bien défini pour ce bijoux des tiling window manager, il fallait donc faire un code en conséquence, la fut le but premier de WMFS2.
Ainsi, cette nouvelle version dispose d'une architecture toute nouvelle, et toute propre. Cela signifie donc : de nouvelles fonctionnalités, d'anciennes fonctionnalités améliorées, et d'autres à venir.
Actuellement, si vous avez WMFS1, vous disposez des fonctionnalités suivantes :
La plus importante des nouveautés est au niveau du tiling, désormais il est entièrement manuel (il fut appelé un temps split layout). Les fenêtres sont splittées automatiquement (verticalement ou horizontalement selon la taille du client) et vous pouvez les redimensionner comme bon vous semble.
Mais ce n'est pas la seule nouveautés, xorg62 a introduit le concept des presets, un historique des dispositions des clients. Ainsi lorsque vous redimensionnez un client, vous pouvez revenir à la disposition précédent le redimensionnement, ingénieux non ?
Plusieurs clients dans une seule frame ? C'est désormais possible, vous pouvez tabber vos clients dans toutes les directions, et lorsque vous souhaitez les untabber, ces derniers reprennent leurs anciennes places.
Oui, j'ai bien dit les. Avec l'apparition de la section bars dans la configuration, on peut ainsi créer de multiples infobar. Dans cette section de la configuration, on peut donc nommer chaque infobar et choisir quels éléments seront présents dedans :
[bars]
# Elements :
# t - Tag list
# s - Status
# more elements are coming
[bar]
name = "topbar"
screen = 0
position = 0
elements = "t"
theme = "default"
[/bar]
[bar]
name = "botbar"
screen = 0
position = 0
elements = "s"
theme = "other_theme"
[/bar]
[/bars]
Notre cher xorg62 a donc concentré toutes les options graphiques (couleurs, fonts, etc...) dans une section de la configuration. Mieux, il a introduit la possibilité de créer plusieurs thèmes, vous pouvez donc choisir un thème spécifique pour une infobar en particulier, ou alors définir (à l'aide des rules) un thème différent pour certaines applications, les possibilités sont multiples !
[themes]
[theme]
name = "mon_theme"
font = "fixed"
#...
[/theme]
[theme]
name = "autre_theme"
font = "terminus"
# ...
[/theme]
[/themes]
C'est le seul endroit de WMFS2 ou j'ai participé. Vous vous souvenez de wmfs -s et de wmfs -c ?
Cela vous permettait d'envoyer un nouveau statustext, et de lancer quelques fonctions de WMFS.
Ceci a été remplacé par un FIFO :
$ echo "spawn urxvt" > /tmp/wmfs-$DISPLAY.fifo
$ echo "status <infobar name> <statustext>" > /tmp/wmfs-$DISPLAY.fifo
Bon, et maintenant, il vous reste plus qu'Ã prendre votre cher conky, Ã lui faire afficher sur la ligne de commande
"status <infobar name> ..." et enfin :
$ conky > /tmp/wmfs-$DISPLAY.fifo
Les possibilités sont encore une fois multiples !
Le launcher, le systray et certaines uicb (user interface callback) n'ont pas encore été implémentées, mais cela ne saurait tarder.
Je vous invite à tester cette nouvelle version qui promet d'être encore plus énorme que la première !!
http://github.com/xorg62/wmfs (wmfs1 a été sauvegardé dans une branche du même nom, on ne jette pas le code nous).
Vous connaissez sûrement déjà Bitlbee :)
Vous savez, le logiciel qui permet de concentrer tout vos comptes de messagerie instantanée en un seul client. Je l'utilise ici pour :
Pour connecter mon compte Google, ce fut plutôt simple :
account add jabber username@gmail.com
account set <id> server talk.google.com
account set <id> port 5223
account set <id> ssl true
account set <id> password <password>
Cependant, si comme moi vous êtes inscrit sur Google+, vous devez voir apparaître certains contacts du style _0azig9zf18wpr3v68lfn0y4dw1.
Un peu moche vous ne trouvez pas ? Il s'agit en fait des contacts présents dans vos cercles.
Voici donc la solution, trouvée ici même :
account set <id>nick_format %-@full_name
Reconnectez vous, et le tour est joué!
Dans un article précédent, je vous avez parlé des fonctions asprintf() et vasprintf() et présenté un code permettant de les implémenter.
Cependant, si vous êtes en 64 bits, ce code ne fonctionnera pas et vous obtiendrez des choses de ce genre @3ÂÿÃ.
Voici donc le code corigé :
#define _BSD_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
/* Si va_copy n'est pas défini, gcc défini cette macro */
#ifndef va_copy
# define va_copy(d,s) __va_copy(d,s)
#endif
int vasprintf (char **ret, const char *fmt, va_list args)
{
va_list ap;
char c = 0;
int size = 0;
if (ret == NULL)
return -1;
/* on copie la liste des arguments
* En effet à chaque utilisation de va_arg (utilisé dans *printf()),
* le pointeur est incrémenté.
*/
va_copy (ap, args);
size = vsnprintf (&c, 1, fmt, args);
*ret = calloc (size + 1, 1);
if (!(*ret))
return -1;
/* args étant déjà utilisé, on utilise la seconde liste copiée précédemment */
size = vsprintf (*ret, fmt, ap);
return size;
}
int asprintf (char **ret, const char *fmt, ...)
{
va_list args;
int sz = 0;
va_start (args, fmt);
sz = vasprintf (ret, fmt, args);
va_end (args);
return sz;
}
Juste pour le fun, voici un code des différentes macros agissant sur les va_list (que j'avais écrit à l'époque ou je développais PuddingOS):
#ifndef __STDARG_H
#define __STDARG_H
typedef char *va_list;
#define va_start(ap, p) (ap = (char *) (&(p) + 1))
#define va_arg(ap, type) ((type *) (ap += sizeof(type)))[-1]
#define va_copy(aq, ap) aq = ap;
#define va_end(ap)
#endif /* __STDARG_H */
Cet article se destine notamment aux utilisateurs avancés du langage C.
Vous connaissez donc sûrement la méthode pour intégrer de l'assembleur dans votre code C :
asm ("movl $10, %eax;"
"movl $20, %ebx;"
"imull %ebx, %eax;"
);
Vous savez sûrement que le mot clé asm est désactivé par défaut avec GCC :
-ansi and the various -std options disable certain keywords. This causes trouble when you
want to use GNU C extensions, or a general-purpose header file that should be usable by all
programs, including ISO C programs. The keywords asm, typeof and inline are not available
in programs compiled with -ansi or -std (although inline can be used in a program compiled
with -std=c99 or -std=c1x).
Il est donc préférable d'utiliser le code suivant :
volatile __asm__ ( "movl $10, %eax;" "movl $20, %ebx;" "imull %ebx, %eax;" );
L'assembleur de GCC, gas, utilise la syntaxe AT&T, qui est, selon moi, moche et illisible. Ayant fait pas mal de développement en Assembleur x86 (notamment sur un OS 16 bits totalement écris en Assembleur, et quelques partie de SlightX et ces ancêtres), je peux donc dire que la syntaxe Intel est bien plus agréable.
Je trouve dommage d'intégrer une syntaxe aussi moche que l'AT&T dans un langage aussi bien conçu que le C (R.I.P. Dennis Ritchie).
Apprenez cependant qu'il est possible d'intégrer du code assembleur Intel au lieu de AT&T.
Il suffit d'ajouter l'instruction .intel_syntax au début de votre code ASM.
NB: L'instruction .intel_syntax noprefix permet de ne pas avoir à écrire de % devant le nom des registres.
volatile __asm__ (
".intel_syntax noprefix\n\t"
"mov eax, 10\n\t"
"mov ebx, 20\n\t"
"mul ebx\n\t"
);
NB: Pour revenir à la syntaxe AT&T, il vous suffit d'utiliser l'instruction .att_syntax
Jusque maintenant, lorsque je créais un nouveau dépôt Git, je faisais comme ceci :
$ git init
$ git add ...
$ git commit -am "Initial commit"
Ce qui avait pour effet de prendre les fichiers existants et de les committer.
Rappelons le fonctionnement de Git :
HEAD qui pointe vers un commit en particulierOn a donc par exemple :
Le commit initial n'a pas de parent, il n'est donc pas possible d'effectuer d'actions sur ce dernier.
Prenons l'exemple de git rebase -i qui demande un commit de référence, si vous avez du contenu dans
le commit initial, vous ne pourrez le modifier car ce commit est la référence. Alors que si le commit
initial est vide, la totalité du contenu est accessible.
Une bonne pratique est de toujours travailler dans des branches, et ensuite de merger dans master. Le commit initial est obligatoirement dans la branche master, si ce commit est vide, vous n'avez alors aucun contenu expérimental dans master.
La méthode à suivre est plutôt simple :
$ git init
$ git commit --allow-empty -m "Initial commit"
$ git add ...
$ git commit -am "..."
Je vous conseil cependant :
$ git init
$ git commit --allow-empty -m "Initial commit"
$ git checkout devel
$ git add ...
$ git commit -am "..."
Car il est préférable de développer dans des branches :)
Il y a peu j'ai déplacé mon site web sur github. Et donc également mon blog. Ceci implique donc certaines restrictions, mais décrivons avant ce que propose Github, vous comprendrez tout de suite :)
Pour rappel, github est une forge, malheureusement non-libre, qui propose d'héberger les projets des utilisateurs dans un dépôt git. Comme toutes forges, github implémente les fonctionnalités suivantes :
close #45 dans le message, cela fermera le ticket n°45).git archive)Mais github propose bien d'autres choses :
Le concept est simple. Imaginons que l'utilisateur example soit inscrit sur github. Celui ci va créer un dépôt nommé example.github.com.
Il va ensuite y placer quelques pages HTML et un fichier CNAME contenant example.com. Il va ensuite configurer son nom de domaine pour pointer vers
les serveurs de github.
Le résultat sera le suivant : http://example.com pointera vers le site web stocké dans le dépôt précédemment créé, et http://example.github.com le
redirigera sur http://example.com.
Le site web est donc géré via git, vous committez de nouvelles pages et pushez pour mettre le tout en ligne, pas besoin de FTP/rsync/SSH/... Je trouve ça tellement pratique :D
Voila vous avez désormais votre site web sur github.
NB: github n'accepte que du contenu statique (donc (x)HTML). Vous ne pourrez envoyer de PHP, python, perl ou autre.
Bon, on a un site internet sur github, c'est bien beau mais ensuite ? Ensuite on va créer un site par projet !
Dans le dépôt git de votre projet, faites ceci :
$ git checkout --oprhan gh-pages
Ceci va créer une branche, sans contenu, nommé gh-pages. Dans cette branche vous stockez le site web de votre projet.
NB: Cette méthode est faisable via l'interface d'administration de votre projet.
Vous aurez donc le site de votre projet stocké à l'adresse http://example.github.com/monprojet (enfin plutôt : http://example.com/monprojet/).
NB: Le fichier CNAME marche tout aussi bien pour les projets, mettez le simplement dans votre branche gh-pages.
Simple : que du contenu statique, rien de dynamique. Voila le problème qui s'est posé lorsque j'ai eu besoin de passer mon blog (anciennement propulsé par pblog) sur github.
La solution est donc de migrer le blog sur un générateur de blog statique. Heureusement j'avais concocté un petit outil de se genre. Souvenez vous de plstblog (mentionné ici et ici).
C'est donc avec un petit script shell que j'ai extrait les articles de la base de donnée de pblog pour les utiliser avec plstblog.
Un peu de jQuery par-ci par-là (jquery.dataTables.min.js pour l'index) et on a un jolie blog digne de ce nom ! :)
Je suis content de vous annoncer que Cream-Browser est désormais thémable en CSS !
Après avoir supprimé le support de GTK+-2.0, j'étais donc apte à utiliser les fonctionnalités de GTK+-3.0, indisponible sous GTK+-2.0. Des fonctionnalités telles que le GtkCssProvider.
Au lieu de charger un GtkRc, GTK+-3.0 charge une feuille de style CSS.
Selon moi, GtkRc c'est juste de la grosse merde (une syntaxe dégueulasse, peu documenté, etc...), si j'avais voulu garder GTK+-2.0, j'aurais dut utiliser les fonctions de tunning de GtkWidget, autrement dit : la galère à vue d'oeil. Encore une bonne raison de supprimer le support de GTK+-2.0.
Si vous ne voulez pas utiliser le thème par défaut de GTK, vous n'avez qu'à écrire une feuille de style CSS situé dans ~/.config/cream-browser/theme.css.
Un exemple de thème est déjà disponible sur le dépôt git.
Enjoy :)
Aujourd'hui, j'ai supprimé le support de GTK+-2.0 (et malheureusement DirectFB, car GTK+-3.0 ne le supporte plus non plus).
Pourquoi j'ai fait cela ?
Ainsi, je ne maintiendrai pas le support des deux versions plus longtemps, je vous invite donc à installer GTK+-3.0 si ce n'est déjà fait.
Il y a quelque temps, j'ai découvert la commande git-stash.
Celle ci permet de mettre en cache les modifications apportées sur un dépôt sans les committer.
Utile pour faire un bugfix alors que vous êtes en train de coder.
modifications...
$ git stash save "save current modifications"
our tree is now at the HEAD commit
doing some stuff...
$ git commit -am "bug fix"
$ git stash apply
Comme on peut s'en douter, des conflits peuvent arriver lors du git-stash-apply, tout a été prévu grâce à la commande git-stash-branch :
$ git stash branch stashing
Same as :
$ git checkout -b stashing
$ git stash apply
Ici un merge permettra de résoudre les conflits :)
Pour voir la liste des modifications mises en cache :
$ git stash list
Et maintenant la liste des commandes de git-stash extraite du man (que je vous invite à lire) :
git stash list [<options>]
git stash show [<stash>]
git stash drop [-q|--quiet] [<stash>]
git stash (pop | apply) [--index] [-q|--quiet] [<stash>]
git stash branch <branchname> [<stash>]
git stash [save [-p|--patch] [-k|--[no-]keep-index] [-q|--quiet] [<message>]]
git stash clear
git stash create
Avec un tel système on pourrait donc créer un système de cache basé sur git, à travailler ^^
Imaginez que vous ayez deux dépôts git :
|--- repo1
| |--- .git
| |--- file1
|--- repo2
| |--- .git
| |--- file2
Vous souhaitez merger la branche master de repo2 dans la branche master de repo1.
Le problème étant posé, passons à la solution :
$ cd repo1
$ git checkout --orphan merging
Ici on créé une nouvelle branche sans commit history, ainsi le prochain commit dans cette branche sera le commit initial de cette branche. Pratique pour développer deux projets liés sur un même dépôt !
$ git remote add merge ../repo2/.git
$ git pull merge master
Ici on ajoute en tant que remote le second dépôt et on pull la branche master de celui ci dans notre branche orpheline.
NB: certains préféreront à git pull ceci :
$ git fetch merge master
$ git merge FETCH_HEAD
Ceci récupère les données du dépôt et effectue ensuite un merge dans la branche (plus efficace pour régler les conflits de pull, bien qu'ici il s'agit d'une branche vide).
On vient donc d'importer la branche master d'un autre projet dans la branche merging de l'actuel.
Pour la suite il s'agit d'un merge tout simple :
$ git checkout master
$ git merge merging
Nous n'avons plus besoin de la branche et du remote, supprimons les.
$ git branch -d merging
$ git remote rm merge
On voit encore une fois la richesse des commandes git !
Bonjour!
Après 2 mois d'inactivité sur Cream-Browser je reviens avec quelques commits. On notera dans ces commits l'intégration de la Statusbar aux autres widgets, quelques petites améliorations sur le support de WebKit, et notament, les KEY BINDINGS.
Tant attendu par moi-même, j'ai finalement committé ceci aujourd'hui à 17h00 tapante.
17:00 <CIA-69> cream-browser: David Delassus unstable * r0feb308 / (21 files in 3 dirs): Add keybindings (soon a note on the blog) - http://git.io/In8GfA
L'ajout de key-bind est assez simple :
cream.keys.map (statelist, modkeys_list, command, callback)
statelist correspond à la liste des états de Cream-Browser (les modes de fonctionnements, en insertion, etc...), voici les modes existants :
cream.state.insert -- Le focus est dans un <input>/<textarea>/autre contenu éditable
cream.state.command -- Le focus est dans l'Inputbox
cream.state.search -- Le focus est dans l'Inputbox, en mode recherche
cream.state.embed -- Un plugin (ex: flashplayer) a le focus (pas encore implémenté)
cream.state.caret -- Navigation au clavier (pas encore implémenté)
cream.state.normal -- Mode normal
cream.state.all -- Tout les états
Voici un exemple :
cream.keys.map ({ cream.state.all }, { }, "Escape",
function (w)
cream.inputbox.text ("")
cream.state.current (cream.state.normal)
end)
cream.keys.map ({ { cream.state.normal, cream.state.embed, cream.state.caret }, { "Shift" }, "colon",
function (w)
cream.inputbox.text (":")
cream.inputbox.focus ()
end)
-- Paste command \o/
cream.keys.map ({ cream.state.normal, cream.state.embed, cream.state.caret }, { }, "pp",
function (w)
uri = cream.clipboard.primary:get ()
if uri ~= "" then
w:open (uri)
end
end)
NB: Vous devez préciser les modkeys même pour les touches ne le nécessitant pas (ex: { "Shift" }, "colon" donera ":")
NB: Vous devez écrire le nom complet des touches (ex: minus et non -)
Have fun! :)
Git est un outil merveilleux qui ne se limite pas à un simple gestionnaire de version.
En effet il peut être utilisé pour de nombreuses choses telles que :
Et encore d'autres que je ne soupçonne même pas.
La solution est bien simple, imaginons que vous souhaitez faire un backup de vos configurations situés dans votre HOME, voici la procédure :
$ git init
Initialized empty Git repository in /home/linkdd/.git/
$ git add .config .vim .vimrc ....
$ git commit -am "Initial commit"
Ici on a donc tout simplement créé un dépôt git et commité dedans ce que l'on souhaitait sauvegarder.
Nous souhaitons faire notre backup dans le dossier /mnt/backup (situé sur un autre disque, une clé USB, NFS, ou autre), clonons tout simplement le dépôt :
$ cd /mnt/backup
$ git clone --bare /home/linkdd/.git myhome.git
$ cd
$ git remote add origin /mnt/backup/myhome.git
Maintenant dès que vous faites une modification dans votre home, git commit/git push vous permettra de tout sauvegarder.
NB: git clone --bare permet de cloner uniquement le dossier .git et non votre HOME complet.
NB2: Grâce à l'historique de git, vous avez la totalité des backups fait (ça change de rsync)
$ git repack -d
$ git prune
Permettra de compresser votre dossier .git
$ cd /mnt/backup/myhome.git
$ git repack -d && git prune
Compressera ici votre dossier de backup.
$ git init --bare /mnt/backup/homes.git
$ cd
$ git remote add backup /mnt/backup/homes.git
$ git push backup master:linkdd
On initialise un nouveau dépôt, et on push la branche master de notre HOME dans la branche linkdd du dépôt de backup, faites ceci avec tout vos utilisateurs et vous aurez ainsi tout les HOME de vos utilisateurs sauvegardés dans un seul dépôt.
Prenons un exemple simple, imaginons que je sois parti en vacances, j'ai pris pas mal de photos que j'ai stocké sur mon ordi (dans le dossier ~/Images). Je créé un dépôt git :
$ cd ~/Images
$ git init
$ git add *
$ git commit -am "Initial commit"
$ git remote add git@github.com:linkdd/images.git
$ git push origin master
Ici on initialise le dépôt git, et on push le tout sur un dépôt distant (par exemple sur Github en imaginant que vous ayez un dépôt privé).
Sur vos autres ordinateurs il vous suffira de faire git clone git@github.com:linkdd/images.git et de git pull à chaque envoie de photos.
NB: On peut aussi tout simplement faire git clone ssh://linkdd@192.168.1.132:/home/linkdd/Images/.git Images si cela ne quitte pas votre réseau local. Si vous avez un serveur git personnel vous pouvez pusher dessus au lieu de sur github, à vous de voir :)
La procédure est très simple :
$ cd /path/to/your/folder
$ git init
$ git add *
$ git commit -am "Initial commit"
$ tar cvf folder.git.tar .git/
Dans le dépôt, git ne les hashs des fichiers du projet, ainsi qu'un unique fichier qui contient toutes les données dans un format compressé. Les hashs permettent ainsi de s'assurer de l'intégrité du contenu du dépôt et donc de votre archive :)
Pour décompresser votre archive il vous suffira de faire :
$ mkdir folder
$ cd folder
<get folder.git.tar in the current directory>
$ tar xvf folder.git.tar
$ git reset --hard
Ici on restaure le dépôt (dossier .git) et à l'aide de git reset --hard on extrait les données du dépôt pour restituer les fichiers.
Avec git repack -d et git prune vous pouvez encore réduire la taille de votre dépôt et donc compresser encore les données.
Malheureusement vous ne verrez pas GitFS dans votre liste de système de fichier (bien que cela me plairait) mais git possède déjà tout les outils qui le permettrait.
En effet, vous avez la commande git fsck qui vérifie l'intégrité du dépôt git (en imaginant que ce dépôt soit votre système de fichier, cela vérifierai l'intégrité de votre système de fichier).
Un git checkout est bien plus rapide qu'un cp -a, ref:cet article. Dans cet article il explique qu'un git checkout effectue une unique action sur un unique fichier (situé dans votre dépôt .git) là ou un cp -a effectue une lecture du dossier, de l'inode, et du contenu et cela pour chaque fichier. Pour plus de détails je vous invite à le lire ^^
etc...
Git est un outil extrêmement puissant si l'on prend le temps d'apprendre à s'en servir, c'est au point de ne plus pouvoir s'en passer ^^
Maintenant, imaginez une distribution linux ou tout est régi par git. Imaginez que pour installer votre système de base vous cloniez un dépôt git. Imaginez que pour installer un logiciel vous ne fassiez un simple merge. Pour en désinstaller un, un simple git revert suffirai. Les submodule permettrai de personnaliser votre système. Ce concept pourrait reposer sur différents gestionnaires de paquets et cela sans problème. La gestion des différentes architectures serait simplement différentes branches sur un même dépôt. Bref, ce serait le pied :)
Bonjour!
Cela faisait longtemps que je n'avais pas posté sur ce blog! :P Mais je reviens ! pour annoncer quelques news.
Tout d'abord j'ai quitté WMFS pour i3, voici le résultat : screenshot Un bureau bien plus light comme on peut le voir :)
Pourquoi avoir quitté WMFS ? Parce que la version actuelle du git est en pause (xorg62 nous prépare une nouvelle version de WMFS refaite depuis 0 censé éliminer pas mal de bugs et permettre quelques petites choses en plus, en attendant j'ai trouvé son remplaçant) : wmfs2.
Maintenant, abordons mon propre projet. Cream-Browser, depuis 2 mois (depuis que je suis en vacances), rien n'a avancé au niveau du code. Pour l'instant on a une barre de commande basique, une gestion du split à la vim, une gestion basique de webkit etc... Je "bosse" sur la barre de statuts actuellement, cela devrait être terminé en quelque jours si je m'y mets ^^. La suite du programme sera donc d'ajouter un thème un peu moins dégueulasse et plus light que le GTK+ de base, d'améliorer le support de webkit, de finir l'API lua pour la configuration, et le reste ce sera du détail :)
Si je ne trouve pas la motivation pour coder ne vous inquiétez pas, c'est bientôt la rentrée j'aurais du temps à perdre à ne pas étudier ;D
J'ai deux projets qui viennent d'émerger dans mon esprit et que j'ai déjà commencé :
Voila, je pense que c'est tout :P
Bonjour ! Oui je poste de moins en moins, mais voila tout de même quelques news en vrac :
J'ai bien bossé dernièrement sur Cream-Browser, il retrouve donc cmake en tant que BuildSystem. Compatible avec GTK2 (et donc directfb également) et GTK3, etc...
La news la plus importante est je pense l'achèvement du GtkVimSplit, ce merveilleux widget GTK qui me permet de splitter à tort et à travers les vue :) Comme dans vim quoi. La GUI avance bien! :P
Oula ça remonte à loin ça ! Gitli, la distribution linux basée sur git, un projet que j'avais commencé à la va vite il y a longtemps, aussi vite laissé pour mort.
Et bien non, je reprend le flambeau, avec tout plein de nouvelle idées sur comment réaliser la chose, les idées sont dans un .txt rien n'est codé pour le moment ^^
Alors la c'est le coup de coeur du jour, un client twitter en ncurses, merveilleusement bien foutu, agréable à utiliser. Bien mieux que bitlbee ! Je l'ai adopté ^^
WMFS de son coté avance aussi énormément ! xorg62 nous a concocté une toute nouvelle manière de voir le tiling. Une sorte de tiling manuel largement inspiré du (v)split de Vim (oui décidément chez HFT on aime vim). Le concept est simple, on a nos layouts comme avant, mais on peut aisément redimensionner à la main comme on veut etc... bref c'est le pied :)
J'ai ajouté il y a peut le support du flux RSS 2.0 à plstblog (cf ce billet).
Il suffit pour cela d'ajouter dans votre configuration :
rss=yes
rss.title=Your RSS title
rss.link=http://example.com/
rss.lang=en
rss.description=Example of RSS summary
rss.author=author@example.com
Toujours dans le but de faire simple :)
J'ajouterai d'ici peu une variable pour les templates permettant d'ajouter le lien RSS sur la page HTML généré.
Les pages github c'est pratique pour héberger le site de votre/vos projet(s), mais pour un blog c'est une autre histoire.
En effet, vous ne pouvez mettre que du HTML, il vous faut donc un générateur de blog statique. En gros vous écrivez vos articles sur votre machine, générez les pages HTML et envoyez ça sur le dépôt git.
J'en avais besoin d'un simple : un header, l'article, un footer. J'ai donc profité de ce besoin pour apprendre le perl et ainsi né : Perl Static Blog (soit: plstblog).
La configuration est simple (réduite au minimum) :
blogurl=http://example.com/blog
datefmt=%T %D
localpath=/path/to/your/blog
localposts=/path/to/your/articles.markdown
tmpl.top=/path/to/your/header.template
tmpl.bot=/path/to/your/footer.template
tmpl.idx.top=/path/to/your/index/header.template
tmpl.idx.bot=/path/to/your/index/footer.template
Les articles sont écrits dans la syntaxe Markdown
tmpl.top : Le code HTML du header d'un article.tmpl.bot : Le code HTML du footer d'un article.{ % title % } : Titre de l'article.{ % idx % } : Index de l'article.{ % ohidden} : Si l'article précédent n'existe pas, cela vaut "hidden" (vous pouvez par exemple le mettre dans l'attribut de balise class=).{ % nhidden} : Pareil qu'au dessus mais pour l'article suivant.{ % otitle % } : Titre de l'article précédent.{ % oidx % } : Index de l'article précédent.{ % ntitle % } : Titre de l'article suivant.{ % nidx % } : Index de l'article suivant.tmpl.idx.top : Le code HTML du header de la page d'index.tmpl.idx.bot : Le code HTML du footer de la page d'index.La page d'index est donc un tableau de la forme :
<table><thead><tr><th>Title</th><th>Last edition</th</tr></thead><tbody>
<tr><td class="link"><a href="@blogurl@/post/{ % idx % }.html">{ % title % }</a></td><td class="date">Last edition: @date according to datefmt@</td></tr>
<tr>...</tr>
</tbody></table>
Projet à voir sur github. ;)
Bonjour,
M'intéressant à ce sujet pour le développement de Cream-Browser (après un mail dont l'auteur souhaiter porter le logiciel sur OpenPandora), j'ai décidé d'essayer de compiler et lancer Cream-Browser avec le support de DirectFB.
Ceci permet donc de lancer Cream-Browser en framebuffer, et permettra de l'installer sur des systèmes embarqués n'utilisant pas X.
Malheureusement GTK+-3.0 a supprimé le support de DirectFB, cette fonctionnalité n'est donc disponible que pour GTK+-2.0 (heureusement je maintien le support des deux versions).
Je vous invite à lire la page sur le wiki de Cream-Browser pour la marche à suivre : lien.
A venir : des nouvelles de Cream-Browser.
Bonjour!
Je vous donne quelques news de Cream-Browser (il en faut sinon on croit qu'il est mort). Tout d'abord si vous voulez des news régulière je vous invite (une fois de plus) à rejoindre le canal (#cream-browser @ irc.freenode.net)
La branche master contient l'ancienne version de Cream-Browser, elle n'est plus maintenu, en effet je travaille actuellement sur la branche unstable qui se vera intégré dans master une fois prête. Comme son nom l'indique, elle est unstable donc pas utilisable pour un usage quotidien (mais en développement constant cela dit).
Pour ceux qui ne le savent pas, la configuration se fera désormais en Lua. Je fais en sorte que la configuration reste le plus simple possible mais bénéficie tout de même de tout les atouts de lua, pour une grande souplesse. Il y a donc l'API C que Cream-Browser fournira à lua et une librairie lua (à intégrer avec require()) qui intégrera l'API C.
Pas mal de fonctionnalités sont déjà faite (clipboard, regex, modules, etc...) et d'autres restent à venir. Le développement de l'API C suit de très près l'intégration des fonctionnalités dans Cream-Browser.
La est tout l'intéret (selon moi) de cette nouvelle version. Avant, Cream-Browser dépendait de WebKit, et de toute les librairies utilisées pour gérer les protocoles. Si vous n'alliez jamais en FTP ou que vous n'utilisiez pas Gopher (deux protocoles prévus pour l'ancienne version), et bien le support était quand même activé et le tout chargé en mémoire.
Désormais Cream-Browser ne s'occupe (directement) que de l'affichage, il déléguera le chargement des URL a un module (chargé préalablement par GModule). GModule est un outil de la glib qui permet de charger des librairies (.so, .a, .dll) au runtime (pas besoin de compiler Cream-Browser avec le support pour tel ou tel module, il suffit de dire dans votre conf Lua que vous souhaitez tel ou tel module et hop!).
Le but est donc ici d'associer à un module un ou plusieurs protocole. Et quand on charge une URL, Cream-Browser récupère le protocole et vois quel module utiliser. Chaque module fourni donc un widget à Cream-Browser qui se chargera de l'afficher (par exemple: un WebKitWebView pour WebKit, un GtkMozEmbed pour Gecko, etc...).
Ceci permettra donc d'avoir différent module chargé uniquement selon les besoins de l'utilisateur (il désire Gecko ? chargeons le module Gecko. Il préfère WebKit ? allons y. Il ne veut que FTP et non HTTP/HTTPS ? soit qu'il le fasse).
Attention: Cream-Browser continuera d'être développé dans l'optique "navigateur internet", donc l'utilisation de Cream-Browser avec des modules non-orienté internet (terminaux, éditeur de texte, etc...) sera anti-productif. (oui je m'attend un peu à ça de la part de certains emacs-fan :D).
La GLib permet beaucoup de chose, dans une application nécéssitant GTK+ il serait donc domage de re-coder bon nombre de choses que propose déjà la GLib. Je prend l'exemple de la gestion des XDG directories, la GLib propose ceci (*g_get_user_config_dir(), g_get_system_data_dirs(), etc...) mais portable sous tous les OS qui compilent la GLib.
Utiliser massivement la GLib permettera un portage sous différents OS plus aisée (je pense notament à Windows :/ ).
Avec la récente sortie de GTK+ 3.0, j'ai décidé de rendre compatible Cream-Browser avec cette dernière, sans pour autant supprimer la compatibilité avec GTK+ 2.0.
J'utilise donc parfois la macros GTKCHECKVERSION(). Exemple :
static void webview_class_init (WebViewClass *klass)
{
/* On aime bien éviter les Warning à la compilation :) */
#if GTK_CHECK_VERSION (3, 0, 0)
/* Avec GTK3, l'objet GtkObject disparait, on utilise donc GtkWidget désormais. */
typedef void (*DestroyCallback) (GtkWidget *);
GtkWidgetClass *object_class = (GtkWidgetClass *) klass;
#else
typedef void (*DestroyCallback) (GtkObject *);
GtkObjectClass *object_class = (GtkObjectClass *) klass;
#endif
/* Ici webview_destroy a donc pour prototype: void webview_destroy (GObject *obj); */
object_class->destroy = (DestroyCallback) webview_destroy;
En effet GtkObject disparait avec GTK3, donc désormais lorsque je créé un widget, je le base sur GObject (de la Glib), par exemple :
G_DEFINE_TYPE (WebView, webview, GTK_TYPE_SCROLLED_WINDOW)
Il vous suffit d'aller voir quelques tutos GTK2 pour voir à quel point cela simplifie le code :D
NB: Si vous souhaitez utiliser GTK+ 3.0 il vous faut compiler Cream-Browser comme ceci : ./configure --with-gtk=3.0
NB2: Avant chaque commit, je compile Cream-Browser avec GTK2 puis avec GTK3, le support pour les deux est donc parfaitement testé. Merci de bien vouloir me rapporter chaque bugs que vous pourriez trouver. :P
Et oui, on en entend beaucoup parler en ce moment n'est-ce pas ? Alternative très prometeuse à GCC. Il y a 2-3 jours tentant de compiler Cream-Browser avec clang je me suis rendu compte de quelques warnings/erreurs non-présents chez GCC.
Ainsi, de même qu'avec GTK3, Cream-Browser est compilé avec clang et GCC pour assurer une compatibilité parfaite. De même, pour toutes erreurs de compilation veuillez m'en avertir ;)
NB: Pour compiler avec clang : CC=clang ./configure
Cream-Browser est un projet en continuel développement et n'est pas prêt de mourrir ! J'espère pouvoir offrir une interface graphique dans la branche unstable très rapidement (je bosse en ce moment même dessus !).
Convertir un dépot Mercurial vers un dépot Git sans perdre l'historique, une lubie depuis quelque temps ^^
En effet j'avais décidé de tester ce dernier en l'utilisant comme VCS pour un projet. Etant déçu par hg devant son infériorité nette à git (oh le gros troll poilu) j'ai donc cherché à convertir se dépot en dépot git.
Il s'agit d'un script, nommé fast-export. La procédure à suivre est extrêmement simple :
$ git clone git://repo.or.cz/fast-export.git
$ git init my_git_repository
$ cd my_git_repository
$ ../fast-export/hg-fast-export.sh -r /path/to/old/repository-hg
$ git checkout HEAD
Et le tour est joué. L'historique est conservé (voyez par vous même avec git log) y compris les dates des commits.
Twitter @debian (2h heure locale)
#debian #squeeze is now being pushed to mirrors around the world. This is it people, we have released!!
Debian 6.0, alias Squeeze est donc sortie! Squeeze, le nom du petit martien aux trois yeux dans Toy Story (pour rappel chaque version de Debian prend le nom d'un personnage du film), anciennement le nom de la version testing est donc passée stable.
Rappellons d'abord le principe de version de Debian.
Un tel système permet ainsi des tests efficaces sur les logiciels pour une stabilité parfaite du système, au prix de versions légerement anciennes (que certains nommeront obsolètes). Lors du cheminement du paquet jusqu'à la branche stable, ce dernier peut subir des modifications de son code source afin d'obtenir une meilleure intégration avec Debian (on notera l'exemple de Iceweasel clone de Firefoxet de Icedove clone de Thunderbird).
Ceci est totalement opposé au concept de rolling release dont le principe est de fournir continuellement les versions les plus récentes des logiciels. Je citerai ici Gentoo, système extrêmement stable et toujours à jour (et pour cause, c'est une distribution dite source où le gestionnaire de paquet compile logiciel voulu au lieu de télécharger le binaire) : il arrive parfois qu'un logiciel ne compile pas (incompatibilité entre versions), il suffit d'attendre une heure ou deux, la mise à jour des paquets (un correctif pour régler le problème). Ceci n'arrive pas sous Debian car tout est testé et retesté avant la sortie de la version
Une version de Debian sort quand elle est prête, jamais de date n'est prévue.
Les nouveautés principales sont donc :
Me voici donc en train de télécharger Debian Squeeze (GNU/Linux et GNU/kFreeBSD) afin de pouvoir réaliser des tests plus en profondeur (évidement je vais pas mettre Gentoo sur un labtop :/ c'est pourquoi* Debian GNU/kFreeBSD* me tente bien).
Bonjour!
Vous connaissez surement Allociné, le site qui vous donne nombre d'informations sur un film (affiche, synopsis, acteur/réalisateur, annéem casting, bande-annonce, etc...).
Pour quelqu'un qui possède enormement de film (pourquoi vous me regardez :-°), pouvoir accéder rapidement aux infos d'un film (avant de le téléch... acheter :) ) c'est important. Et même une fois stocké sur votre disque externe et que vous devez choisir un film à regarder (genre un film vu il y a looooooongtemps), c'est primordial!
Devoir ouvrir un navigateur internet (heureusement que j'ai dwb c'est rapide ^^) et charger le site d'allociné, ensuite taper le titre du film puis .... Bref c'est long.
De nombreux logiciels existent et vous permettent de vous faire une vidéothèques, mais moi ce que je désire c'est :
Bon, quel rapport avec allociné ? Et bien il se trouve qu'il va m'être aisé de développer ceci grâce à une API (plutot que parser le html du site, beurk beurk). Tout de suite le lien ! http://wiki.gromez.fr/dev/api/allocine
Enjoy! ;)
Bonne année à tous !
Mes résolutions ? 1280x1024 pour chacun de mes écrans (aaah le classique)
Meilleurs voeux (du genre : "pas d'IPcalypse", "HADOPI et LOPPSI annulées", "Internet gratuit à haut-débit cablé en fibre optique pour tout le monde", etc...)
Récupérez bien de votre cuite et demain au boulot ! :-(
J'ai donc "découvert" LaTeX ("enfin" diront certains).
Je tatonne un peu, je teste j'expérimente. Cela me permet donc de rédiger des documents bien plus efficacement (mon CV va bientôt y passer).
Mon premier document est donc la présentation d'un algorithme de chiffrement à l'aide de matrice : lien du document (pdf)
Je suis très satisfait de LaTeX, à long terme, peut-être que je pourrais virer LibreOffice ^^
L'IPcalypse, un terme que l'on rencontre assez souvent ces derniers temps.
Qu'est-ce que c'est ? Est-ce réellement aussi grave que certains sites le prétendent ? Pourquoi en faire un buzz aussi conséquent ?
Début de l'internet, on créé le protocole IPv4 permettant d'allouer près de 4,3 milliards d'adresses différentes. Une adresse IPv4 longue de 32 bits se présente donc sous la forme de 4 nombres séparés par des points compris entre 0 et 255. Voici un exemple : 192.168.1.132.
Il y a de cela une dizaine d'année, en prévision du futur manque d'addresse IPv4, on crée le protocole IPv6 (le protocole IPv5 semble être passé à la trappe). Une adresse IPv6 est composé de 8 nombres hexadécimaux compris entre 0 et 0xFFFF (donc 2 octets) séparé par le symbole ":". L'adresse IPv6 est donc longue de 128 bits et permetterait l'allocation de 2^128 adresses différentes. Voici un exemple : 2001:0DB8:0000:85A3:0000:0000:AC1F:8001
Précisons : disponibles à l'allocation. En effet les FAI loue les adresses IPv4 afin de les revendre à leurs clients. Il reste donc moins de 5% d'adresses non-alloué, mais le calcul réellement intéressant serait de savoir combien sont vraiment utilisées ?
Imaginez. Nous sommes dans une ville (fictive) possédant 100 maisons. Trois agences immobilières sont présentes. Elles ont achetés chacune 30 maisons. Il en reste 10 non-achetés, cela veut-il dire que seul 10 habitants peuvent venir en ville ?
Cependant les FAI vont profiter de ce manque d'IPv4, ce type d'adresse devenant une denrée rare son prix augmentera (c'est normal après tout).
Je dirais oui et non, non dans le sens ou on en entendra parler encore quelques années car les FAI utiliseront les IP non utilisées pour les clients (je suis en IP dynamique, mon ancienne IP sera celle d'un autre client demain ?) et tant que ca marche ils ne passeront pas au nouveau protocole. Mais voila, 4,3 milliards de connectés c'est pas impossible :
Tout ca nous donne beaucoup, beaucoup, beaucoup d'IP à utiliser. La réelle arrivée d'IPv6 ne se fera que lorsque toutes les adresses IPv4 seront utilisées.
La norme IPv6 étant différente de la norme IPv4 implique que pour la mettre en place il faut mettre jour nombre de logiciels réseaux, de serveurs, de protocoles internet, etc...
Imaginez que les 3/4 des sites indexés par Google ne supportent pas l'IPv6 (ce nombre est fictif), un passage brutal à ce protocole ferait perdre la place de Google en tant que premier moteur de recherche (notez que tout les serveurs de Google et ses services supportent l'IPv6).
Bien que de nombreux logiciels ce soient mis à jour pour ce support (les plus important étant les noyaux des systèmes d'exploitation), certains depuis quelques années déjà , il reste encore beaucoup de travail.
Nous en tant que client ? rien. Sachez cependant que, à ma connaissance, seul Free et Nerim proposent à ses clients de l'IPv6 (à croire que Orange n'en entend pas parler...).
J'attend impatiemment vos avis ;-)
Bonjour!
Comme vous le savez, mon serveur tourne sous Gentoo. Les compilations sont un problème de temps et de CPU. Mais plus maintenant !
J'ai découvert il y a 2-3 jours ccache. Un utilitaire qui mets en cache les compilations (dans le dossier /var/tmp/ccache). Ainsi si vous compilez le même fichier ensuite, ccache va chercher dans le cache, s'il y est, une bête copie, sinon on compile réellement.
Après quelque jours de test, je suis stupéfait. J'obtiens une telle rapidité de compilation!
Voici comment le mettre en place :
# emerge -av dev-util/ccache
Dans votre /etc/make.conf :
FEATURES="ccache"
# Spécifiez la taille du cache
CCACHE_SIZE="2G"
Si après ça cela ne marche pas :
# cd /var/tmp
# mkdir ccache
# chown portage:portage ccache
# chmod 775 ccache
# echo "CCACHE_DIR=\"/var/tmp/ccache\"" >> /etc/env.d/99local
# env-update
# source /etc/profile
Et voila :) enjoy!
Bonjour!
Je vous parlerai un peu de ma vie aujourd'hui. Depuis un an à peu près je tiens un petit serveur local qui me gère quelques trucs notament :
Bon, je vais vous faire rire un peu (beaucoup) en vous donnant la configuration du hardware de ce serveur :
Hmmm, :/ Heureusement que j'ai du nouveau matos arrivé il y a peu qui me permet de relever le niveau :
Bref c'est bien mieux :) Voici ce que je prévois de lui faire faire :
Pourquoi tant de VZ ? Tout simplement car je tiens à séparer nettement chaque serveur, isoler les failles de l'un aux failles des autres. On peut observer ceci : Une VZ pour utiliser le serveur, une pour y déposer du code, une pour jouer, une pour se connecter à internet via un réseau caché/crypté, une pour publier des sites webs, et enfin une pour les mails. Chacune à un rôle différent :)
Le tout sous une belle Gentoo, dailleurs voici un ptit tips :
Ici on démarre une VZ dont la template est une Gentoo
# vzctl start 777
On monte le dossier /usr/portage dans la VZ
Attention: /vz/root est le chroot de la VZ une fois lancé tandis que /vz/private
est une copie de sauvegarde, ne pas monter l'arbre portage dedans!
# mount -o bind /usr/portage /vz/root/777/usr/portage
# vzctl enter 777
Entered in VZ 777
# emerge -av vim
Enjoy ;)
Hier, le développeur Mike Galbraith proposa un patch de pas moins de 224 lignes de code au noyau.
Ce patch extrêmement court réorganise l'ordonnanceur. L'ordonnanceur (en anglais: scheduler) est le composant qui gère la répartition des tâches, en gros c'est le coeur du multi-tâches. Il s'occupe plus précisément de la répartition des différents processus entre les coeurs du/des processeur(s) présent et de leurs donner "la parole" selon un ordre de priorité précis.
Nous utilisons courrament le multi-tâche. Prenons exemple sur ma machine, j'ai donc les différents processus lancés :
Avec tant d'application la performance de l'ordonnanceur devient crucial, et c'est sur ce point que le patch influe.
Ces vidéos montrent (avant et après l'utilisation du patch) le lancement de la commande "make -j64" sur le kernel (64 compilations en paralèlle donc) et la lecture de la vidéo Big Buck Bunny :
Votre ordinateur n'ira pas plus vite pour autant, la modification se sentira plutot en profondeur. Ce patch défini donc des groupes de processus. Par exemple vous avez le groupe GUI (= applications graphiques) et le groupes Build (qui contient tout les appels à make), 50% des ressources CPU vont être attribué à chaque (ce qui pourra ralentir la compilation qui habituellement en demanderait 80%, mais ce la augmenterait la fluidité du multi-tâches).
Un patch qui fait l'emmerveillement de Linus Torvald lui même comme on peut le voir dans ce mail.
Bonjour chers lecteurs :)
Un petit billet plutot cours pour annoncer la fin de ma présence sur facebook. C'est fini, game over. Certains diront "enfin" ou "c'est pas trop tôt" :)
Pourquoi maintenant ?
Par quoi vais-je le remplacer ? Commençons par énumérer les outils que j'utiliser :
Comme quoi on peut vivre sans facebook !
(2ème jour)
Haha! Que de bonheur en ce lendemain d'halloween (je n'ai plus de bonbons :'( )
Bref, je vais vous faire aujourd'hui un compte rendu sur le navigateur internet que j'utilise depuis déjà quelque jour. Comme vous le savez je développe Cream-Browser, alors je me tiens informé de ce qu'il se passe ailleurs ^^
La je découvre dwb, un navigateur internet vim-like, basé sur webkit, qui gère le tiling ! Une sacré feature j'ai envie de dire ! :o
Il est à la fois léger et 100% fonctionnel, je dirais presque autant que vim. Et tout autant configurable ^^ Un plaisir pour les yeux et pour votre système. Me satisfaisant dans tout les coin, ah mais nan !
Il gère les proxy oui, mais via une variable d'environnement (http_proxy), variable d'environement qui n'existe pas quand j'appelle dwb via le launcher de wmfs. J'ai donc patché pour intégrer une option dans la configuration, et j'ai également réglé un petit segfault. J'ai envoyé mes deux patchs au zentil developpeur portix qui les a quelques peu modifiés avant de les intégrer :)
Les fichiers de configurations sont créé après la première fermeture de dwb, il existe cependant une interface web pour visionner la configuration (la visionner uniquement). Ma tâche des prochain jours sera de proposer un patch à portix permettant de sauvegarder la configuration via cette interface web (plus accessible pour celui qui découvre :) )
Un ptit screen pour la route :
Tor c'est bien, mais Tor c'est lent !
Je vous ai parlé de Tor dans le billet précédent. La solution que je vous ai suggéré était d'installer un proxy (privoxy) qui redirigeai vos connexions vers Tor. Et hop vous avez une nouvelle IP.
Bon, un petit problème se pose. La navigation devient lente. Pour rappel :
Généralement ce serveur se trouve à l'étranger, ce qui ralenti nettement votre vitesse de transfert (surtout pour les images/vidéos). Une idée m'est donc apparu. Utiliser un cache ! En effet le cache me permet d'accélerer la vitesse de transfert des sites sur lesquels je vais souvent. Plutot pratique :)
J'ai d'abord pensé à utiliser Squid, il a un cache très performant mais il ne gère pas la redirection vers un proxy SOCKS, je suis donc obligé d'utiliser 2 proxy (squid et privoxy). Arg pas terrible, je vous mets quand meme la solution :
# Addresse à écouter
http_port <ip>:<port>
# Redirige les connexions vers privoxy
cache_peer <ip du serveur privoxy> parent <port de privoxy> 7 no-query default
Après à vous de configurer squid comme il vous plait.
Finalement j'ai opté pour polipo, il possède un cache et la redirection vers un proxy SOCKS :) Bref il me permet d'utiliser un seul et unique proxy (pas comme squid oulalala non ^^). Voici comment le configurer :
# Utilisation à la fois pour IPv4 et IPv6
proxyAddress = "::0"
# IPv4 uniquement : proxyAddress = "0.0.0.0"
# Clients autorisés à se connecter, localhost, et le réseau local de ma Box
allowedClients = 127.0.0.1, 192.168.1.0/24
proxyName = "Nom de votre serveur"
# Ici l'addresse de Tor
socksParentProxy = "localhost:9050"
# Je désactive l'interface web
disableLocalInterface = true
# Laisser vide pour désactiver le cache
diskCacheRoot = "/var/cache/polipo/"
Une configuration bien plus simple que Squid ^^
Bonjour chers lecteurs !
Je vais vous parler aujourd'hui de Tor, un logiciel que j'ai testé hier et que j'ai finalement installé sur mon serveur ^^.
Wikipédia vous éclairera mieux que moi sur sa nature :
The Onion Router (Tor) (littéralement : le routage en oignon) est un réseau mondial décentralisé de routeurs, organisés en couches, appelés nÅuds de lâoignon, dont la tâche est de transmettre de manière anonyme des paquets TCP. Câest ainsi que tout échange Internet basé sur TCP peut être rendu anonyme en utilisant Tor. C'est un logiciel libre distribué sous licence BSD révisée.
Ainsi, lorsque vous vous connectez à Internet via Tor, vous passez très probablement par un serveur étranger, ou du moins distinct de votre ordinateur. Vous êtes donc identifiés sur Internet par une IP différente de celle de votre box (adieu hadopi).
Ici on utilisera un proxy qui redirigera les connexions entrante vers Tor, je vous conseil donc privoxy (simple mais ne gère que le HTTP)
Sous debian :
# aptitude install tor privoxy
Sous archlinux :
# pacman -S tor privoxy
Normalement la configuration de tor (/etc/tor/torrc) par défaut est suffisante, vérifiez cependant que SocksPort est bien à 9050.
Configurons désormais privoxy (/etc/privoxy/config), ils vous suffit d'ajouter les lignes suivantes :
listen-address 127.0.0.1:8118
# listen-address 192.168.0.1:8118 pour ouvrir le proxy au réseau local, remplacez 192.168.0.1 par l'IP locale de votre ordinateur
forward-socks4a / localhost:9050 . # il est important de ne pas oublier le .
Il vous suffit désormais de lancer les scripts :
Désormais vous avez un IP différente sur internet, et le serveur Tor auxquel vous vous connectez et différent à chaque lancement de tor.
SocksBindAddress 127.0.0.1 par la ligne SocksBindAddress 192.168.0.1 # changez par l'IP locale de votre ordinateurJe fouille mon pc et je retrouve tellement de chose que je publi un billet tout les 5min !
Ici il s'agit d'un sniffer, tout bête qui va lister les données qui passe par votre ordinateur :
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
char *hex_to_str (char *data, size_t length)
{
char *ret = malloc (length);
int i;
if (ret)
for (i = 0; i < length; ++i)
ret[i] = (data[i] < 32 || data[i] > 126 ? '.' : data[i]);
return ret;
}
void dump(char *data, size_t length)
{
int x, y, z = 0;
for (x = 0, y = 0; x < length; ++x, ++y)
{
if (y == 16)
{
char *tmp = hex_to_str (&data[z], 16);
printf("| \033[33m%.16s\033[00m\n", tmp);
y = 0;
z += 16;
free (tmp);
}
printf ("\033[32m%8.8X\033[00m ", data[x]);
}
while (y < 16)
{
printf(" ");
y++;
}
printf("| \033[33m%.16s\033[00m\n", &data[z]);
printf("\n\033[31mGot a %lu bytes packet.\033[00m\n\n", length);
}
int main(void)
{
int recv_length, sockfd;
char buffer[BUFSIZ];
if ((sockfd = socket(PF_INET, SOCK_RAW, IPPROTO_TCP)) == -1)
{
fprintf(stderr, "Invalid socket\n");
return 1;
}
for(;;)
{
recv_length = recv(sockfd, buffer, BUFSIZ, 0);
dump(buffer, recv_length);
}
return 0;
}
Bon j'ai ajouté des couleurs dans la sortie de printf() pour faire plus jolie mais le principe est la. Donc maintenant à vos éditeurs ! :)
Aaaah la flemme, voila ce qui m'a pouss;e à faire ce script, la motivation est par contre ce qu'il m'a fallu pour rédiger un troisième billet dans la même journée !
Ce script zsh a une fonction simple, lister les dépots archlinux que l'on utilise (ceux ci sont présent dans /var/lib/pacman/[repo].db.tar.gz). On affiche la liste grâce à zenity, on séléctionne, on tape le nom du paquet à chercher, encore une liste, on séléctionne et on nous demande s'il faut l'installer ^^.
Mais d'abord, qu'est-ce que zenity ? Pour faire cours, c'est un logiciel qui permet de faire des boites de dialogues pour ses scripts shell. Je vous invite à aller voir le site.
Bon pour les présentations ce sera tout, voici le code :
TERMINAL=urxvt
# Check available repositories by looking in '/var/lib/pacman'
repositories="all"
for i in `ls /var/lib/pacman/*.db.*`
do
repositories="${repositories}\n`basename ${i%.db.*}`"
done
# Select wanted repository
repo=`echo $repositories | zenity --list --text "Select a repository for your search" --column "Repository"`
if [ "$?" = "1" ]; then # If the user press cancel, we shall quit :)
exit
fi
if [ "x$repo" = "x" ]; then # If no repository were selected, so search in all repositories
repo="all"
fi
# Ask user for the package to search
pkg=`zenity --entry --text="Which package to search in '$repo' ?"`
if [ "$?" = "1" ]; then
exit
fi
# Search the package using 'pacman -Sl'
if [ "$repo" = "all" ]; then
ret=`pacman -Sl | grep "$pkg" | cut -d' ' -f1-2`
else
ret=`pacman -Sl | grep "^$repo" | grep "$pkg" | cut -d' ' -f2`
fi
npkg=`echo $ret | wc -l` # Number of packages founded
# Show results to user
selected=`echo "$ret" | zenity --list --text "$npkg package(s) found" --column "Package"`
if [ "$?" = "1" ]; then # Exit on press 'cancel'
exit
fi
# Ask user if he wants to install the package
selected="${selected//\ /\/}"
zenity --question --text "Do you want install package '$selected' ?"
if [ "$?" = "0" ]; then
$TERMINAL -e sudo pacman -S $selected
fi
Evidement je pourrais amérliorer le script, pour permettre de désinstaller les logiciels (et donc détécter s'ils sont installés), récupérer les infos des paquets etc... Mais zenity deviendrait vite limitant. Peut-être si j'ai le courrage vais-je faire une interface en python, on verra d'ici la fin de semaine :)
PS: Oui je sais, je suis fervant défenseur du logiciel console et voila que je code une GUI pour un travail aussi bien fait en console, mais bon l'ennui nous rattrape vite et la flemme également (click-land = pays de la flemme).
Hum, un deuxième billet dans la même journée c'est rare mais en parcourant le blog de bacardi55 je suis tombé sur cet article.
Qui n'a jamais ragé d'avoir ouvert un fichier dont l'owner est root et de ne pas pouvoir le sauvegarder (readonly quand tu nous tiens). Ce que propose bacardi55 est simple :
:w !sudo tee %
Ici on envoit le contenu de buffer à la commande "sudo tee %", le % signifiant le chemin absolu du fichier en cour d'édition. Ainsi on sauvegarde paisiblement. Vim nous préviens que quelqu'un à modifié le fichier, il suffit de le recharger en appuyant sur R.
Etant bien flemmard, j'ai donc codé une fonction dans mon vimrc :
function SaveRoot ()
exe ":w !sudo tee %"
endfunction
nmap <silent> s :call SaveRoot()<cr>
Enjoy ! :)
Je viens aujourd'hui vous présenter newsbeuter, un lecteur de flux RSS en ncurses.
L'interface est très similaire à mutt et la configuration ultra simple.
Il vous suffira d'éditer le fichier ~/.newsbeuter/urls avec votre éditeur préféré (qui a dit vim ? :o) et il suffit d'y mettre les urls de vos flux rss. Dans mon cas c'est :
http://www.developpez.com/index/rss
http://linuxfr.org/backend/news/rss20.rss
http://linuxfr.org/backend/journaux/rss20.rss
http://linkdd.ydb.me/blog/feed/rss2
http://blog.philpep.org/feed/rss2
http://logram-project.org/feeds/latestnews/
http://www.siteduzero.com/Templates/xml/news_fr.xml
Et vous lancez avec la commande newsbeuter et on obtient :
Ressemblant tellement à mutt, je l'ai placé dans la même instance de screen que celui ci. La prochaine étape ? Tester tmux pour envisager le remplacement de screen :)
Bonjour !
Je ne vous présente pas irssi, merveilleux client IRC en console :) Couplé à bitlbee, c'est un bonheur à utiliser.
Pour rappel, bitlbee est un serveur IRC, vous vous connectez dessus depuis nimporte quel client IRC. La particularité est que ce serveur vous permettra de vous connecter à MSN, Jabber, ICQ, et autres protocoles, et cela à partir de votre client IRC ! Aucun plugins nécessaire, car c'est bitlbee qui gère le tout, vous discuttez via IRC avec bitlbee, bitlbee discutte via MSN avec votre contact, et vice-versa :)
Ce que je viens de découvrir, c'est que bitlbee gère l'API de twitter, ainsi vous pouvez tweeter, retweeter, etc... depuis votre cher irssi !
Ajouter le compte :
> account add twitter <username> <password>
Modifier l'affichage des contacts, les valeurs possibles sont : one, many, chat
> account <id> set mode chat
Vous connecter :
> account <id> on
Bitlbee va vous ouvrir un query :
11:45:07 <twitter_bitlbee> To finish OAuth authentication, please visit http://api.twitter.com/oauth/authorize?oauth_token=xxxxxxxxx and respond with the resulting PIN code.
Cliquez sur le lien, cliquez sur autoriser, vous obtiendrez un code qu'il vous suffira de taper dans cette query. La, un nouveau canal s'ouvre, tout vos contacts sont connectés à ce canal.
Pour retweeter :
> rt <nickname>
Pour annuler le dernier tweet :
> undo
(ne plus) Suivre <username>
> (un)follow <username>
Le reste est considéré comme un tweet
Faites help set commands dans la fenetre de status de bitlbee pour plus d'info :)
Il y a eu 2 grandes étapes dans Cream-Browser.
La première fut dans mes débuts avec WebKit, j'apprennais à maitriser la librairie, j'ai donc codé une interface inspiré de Vimpression. Avec le temps je décide de continuer le projet (soutenu par quelques geeks impatient de le voir aboutir). Le code était fait pour supporter uniquement WebKit, donc avec l'ajout de fonctionnalité telle que le FTP, le code devint lourd et difficile à maintenir, pas forcément optimisé.
Avec le recul j'ai décidé de reprendre le code depuis 0 et de rectifier mes erreurs, c'est la que commence la seconde étape. Je décide de séparer l'integration de WebKit (et autre feature), pour en faire une librairie statique, de l'interface principale. J'ai réalisé plusieurs objet, un objet qui intègre WebKit (le ModuleWebView), un qui intègre le FTP (le ModuleFtp, initiallement réalisé avec Curl), un qui intègre les pages en about:, etc... J'ai ensuite réalisé un unique objet CreamView qui s'occupait de charger le module selon le protocole demandé. Voila pour la librairie statique (qui intégrait également la configuration du browser). Dans la partie interface, il y avait l'objet CreamTabed qui intégrait le CreamView avec la barre de status et la barre de saisie, le tout pour être ajouté tel quel dans le notebook (pour les onglets).
Cependant, encore une fois j'ai été trop vite. Je me suis empressé d'ajouter des fonctionnalités, sans même prendre le temps de régler les bugs de celles déjà présente. J'ai ensuite ajouté la gestion des plugins, dans la partie interface. Sauf que les plugins intérragissent avec le CreamView. Malheur ! Voici l'une des nombreuses inter-dépendances entre la librairie et l'interface (l'interface dépend de la librairie qui dépend de l'interface, aie aie).
Encore une fois, je prend du recul, j'observe mon code. L'idée est belle :
Le problème ? Je n'ai pas correctement réfléchi à l'organisation du code, ainsi la partie gérant la configuration se retrouve dans la librairie, la partie gérant les plugins se retrouve dans l'interface. Le code a subit tellement de modification depuis l'idée de base qu'il me devient impossible de rectifier le tir.
Que faire alors ? Réécrire une troisième fois le code, de manière plus propre en prenant le temps de régler tout les bugs avant de s'attaquer à une autre feature ? La réponse est oui ! Mais n'ayez pas peur ! Ce nouveau code se basera grandement sur l'ancien, le travail n'est pas perdu, il est juste repensé, refait, amélioré. Et le temps de faire ces modifications je laisse le git tel quel avant d'avoir réimplémenté les fonctionnalités actuelles. Comme l'idée de base est encore présente, dans le meilleur des cas la réécriture prendra 2 jours, dans le pire des cas, une semaine. Il me faut juste trouver la motivation.
Une fois cette réécriture faite, je publierai tout ca sur le git, et je prévois également de passer le site sous redmine (meilleur bugtracker/wiki/roadmap/etc...).
Souhaitons moi courrage pour un meilleur Cream-Browser ! :)
Bonjour !
Je suis l'heureux possesseur d'un Android ! Et là vous vous dîtes "mais qu'est-ce qu'il vient nous narguer celui là ?". Nonon je ne vous nargue pas, je vous en vente les mérites ! :)
Bref, tout ces petits détails font de mon android mon smartphone chéri :D
Bonjour!
Les vacances m'ont empéchés de beaucoup écrire mais je reviens avec un article très intérressant (pour moi du moins, j'espère qu'il le sera pour vous ;) ).
Il s'agit du logiciel Synergy, celui ci vous permettra d'utiliser un seul clavier/souris pour deux ordinateurs (ou plus) et cela via le réseau.
Tout d'abord il vous faudra installer Synergy :
Sous Archlinux :
# pacman -S synergy
Sous Debian :
# aptitude install synergy
Sous Gentoo
# emerge -av synergy
Ceci installe le serveur et le client. Chez moi je lance l'application serveur sur mon PC fixe (le dual screen sur la photo ci-dessus) et je lance le client sur le labtop (qui se connecte au fixe).
Tout d'abord vérifiez vos /etc/hosts.deny, cela peut être embéttant si ils bloquent les connexions ^^.
Editons la configuration du serveur :
# Fichier de configuration de Synergy -- /etc/synergy.conf
# Ici on défini les ordinateurs sur lesquels on utilisera Synergy
# NB: on utilise leurs hostname
section: screens
freeworld: # Mon fixe
arch-labtop: # Mon labtop
end
# Ici on défini leurs emplacement
section: links
freeworld: # Ã gauche de ce PC on a le portable
left = arch-labtop
arch-labtop: # donc le fixe est à droite de celui-ci
right = freeworld
end
Il nous reste plus qu'a lancer le serveur et le client :
Lancer le serveur :
$ synergys -f
Personnellement je préfère le lancer dans un screen pour éviter
d'avoir un term utilisé pour rien : screen -d -m synergys -f
Lancer le client :
$ synergyc -f <IP-du-serveur>
Dans mon cas l'IP est 192.168.1.132 ;)
--> screen -d -m synergyc -f <ip>
Ce logiciel nécéssite X pour être lancé, donc pour le lancer au démarrage je l'ai mis dans mon .xinitrc. J'utilise également ssh sur le labtop pour me connecter au fixe, avec le X11Forwarding (bien qu'un peu lent) pour pouvoir travailler en 64bits alors que le labtop est lui en 32 ^^
Maintenant, have fun ;)
Bonjour!
Tandis que je codais tranquillement en Assembleur ce matin (oui je sais j'ai le réveil dur), essayant de réduire la taille de mes executables. J'ai viré les libs standards pour utiliser les syscalls, j'ai codé directement le header ELF32 dans le fichier source, du coup je compile mon fichier en binaire brut et le voila executable en 91 octets contre 3Mo en C, bref je m'égare.
Je me suis dit, comment pousser la chose ?Et la je découvre ce site. Leur solution était de compresser au format gzip l'executable et de le décompresser lors de l'execution (le script de décompression et l'executable compressé étant concatenés dans un seul fichier). Pour exemple, l'executable brut de Cream-Browser fait environ 6,2Mo, une fois compressé j'obtiens un executable de 1,5Mo.
Cependant la décompression prend du temps! J'ai donc choisi de compresser avec XZ pour 2 raisons :
Voici un petit bench :
| cream-browser | cream-browser (gzip) | cream-browser (xz)
Taille | 6,2Mo | 1,5Mo | 202ko
Time (s) | 0,946 | 5,045 | 1.201
Comme vous le voyez on a une grande perte de temps avec gzip. Alors qu'avec xz on a un gain de place énorme et une perte de temps peu significative.
Voici donc la marche à suivre, un fichier compress.sh :
if [ ! -a /tmp/cream-browser ];then
dd if=$0 bs=1 skip=188 2>/dev/null|xz -cd>/tmp/cream-browser
chmod +x /tmp/cream-browser
fi
/tmp/cream-browser
rm /tmp/cream-browser
exit
Si vous modifiez le script n'oubliez pas de mettre à jour la valeur de skip qui est extrêmement importante.
$ xz -z cream-browser
$ cat compress.sh cream-browser.xz > cream-browser
$ chmod a+x cream-browser
$ ./cream-browser
Enjoy! ;)
Gné!
Gitli, hum décomposons le nom. Git et li. Git ça on connait, le magnifique gestionnaire de version développé par Linus Torvalds. Gestion perfectionné des branches, des remotes etc... Bref une merveille (bien que au code un peu désordonné mais ne tombons pas dans le troll baveux). Li est bien évidement la première syllabe du désormais bien connu Linux. Mais que symbolise cette association ?
La réponse est bien simple. Une distribution linux entièrement géré par git ! Mais quelle idée folle ! Et impossible nous dira-t-on. Que neni, nous n'y croyons pas. Laissez moi vous expliquer le concept.
Tout simplement, clonez le dépot à partir d'un système hôte (livecd après formattage des partitions par exemple) :
# mkdir /mnt/chroot
# cd /mnt/chroot
# git clone git://github.com/additk1ve/master.git
Ou si vous désirez une autre architecture que la principale, clonez une autre branche (x86_64, etc...)
Ici on suppose que vous avez démarré avec Gitli.
# cd /
# git pull
Il vous suffira de clone le dépot /.git de votre disque dur :)
De nouvelles versions de logiciels ? Des paquets construits différements ? Un système de base expérimental ?
# cd /
# git checkout x86_64-testing
Si vous êtes en x86_64 bien évidement :)
Il vous suffit de créer un dépot public, par exemple git@github.com:linkdd/my_gitli.git :
# cd /
# git remote add origin git@github.com:linkdd/my_gitli.git
git add // git commit // other funny git's stuff
# git push origin master
Hop it's done ! :)
Vous connaissez certainement portage (Gentoo), ou les ports BSD. Imaginez un mix des deux, géré par git !
Le concept est simple, on a un dépot git contenant bon nombre de GITBUILD (qui sont de bête script shell qui s'occupe de compiler le dit logiciel). On clone le dépot on lance le script principal (nommé gitports). Celui-ci lance la compilation du logiciel, va l'installer dans une sous=arborescence, y initialiser un dépot git et merger le tout dans / !
Pas clair ? Ca va venir...
# cd /usr
# git clone git://github.com/linkdd/gitports.git
# cd gitports
# ln -sv /usr/gitports/gitports /usr/bin/gitports
Le lien symbolique ajoute ici le script gitports au PATH et permettra la mise à jour automatique lors du git pull
# cp gitports.conf.sample /etc/gitports.conf
Editez ce fichier pour l'adapter à vos besoin.
Pour mettre à jour gitports, un simple git pull suffit.
# gitports install www/cream-browser
Le script cherche si /usr/gitports/www/cream-browser/GITBUILD existe.
Si oui on charge les données du scripts (définition de quelques variables et quelques fonctions utilies)
On lance les fonctions du GITBUILD.
Le logiciel sera installé dans /usr/gitports/www/cream-browser/fakeroot
On initialise un dépot git dans ce dernier dossier et on y ajoute tout le contenu
On retourne dans le dossier racine avec : (ce qui suit est fait automatiquement)
# cd /
# git remote add cream-browser /usr/gitports/www/cream-browser/fakeroot/.git
# git pull cream-browser master
Cette dernière commande pourra être utilisé pour mettre à jour le logiciel après compilation de la nouvelle version.
Ainsi la commande git remote fournira une liste des paquets installés, git remote | grep
Certains détails restent à peaufiner comme la gestion des fast-forwards généré par un logiciel qui installe les mêmes fichiers que le sysbase ou un autre logiciel.
Il suffira de lister les fichiers du fakeroot, les supprimer du trueroot et retirer le remote avec git remote rm
Un travail de forcené nous attend pour gérer tout les problèmes, les résoudres et ainsi fournir une distribution stable et performante. Et purement geekesque (stop troll !!!!! :D), comme nous la décrivons, elle est RTFM (Read The Fucking Manual) car il faudra lire bien attentivement la doc de git autant coté dev que coté user.
Je vous invite à rejoindre le canal #gitli @ irc.freenode.net
SCSS (Sassy CSS) est une extension au CSS, il est fourni par Sass 3. Il vous permet en gros de rédiger des feuilles de style CSS d'une manière plus organisé, avec des variables, des fonctions etc...
$blue: #3bbfce;
$margin: 16px;
.content_navigation
{
color: $blue;
}
.border
{
padding: $margin / 2;
margin: $margin / 2;
border: 2px $blue solid;
}
On peut imbriquer les différentes règles :
table.hl
{
margin: 2em 0;
td.ln
{
text-align: right;
padding-left: 0.2em;
}
}
Et déclarer des portions de code que l'on peut inclure :
@mixin table-scaffolding
{
th
{
text-align: center;
font-weight: bold;
}
td, th { padding: 2px; }
}
@mixin left ($dist)
{
float: left;
margin-left: $dist;
}
#data
{
@include left (10px);
@include table-scaffolding;
}
Vous pourrez voir un exemple ici même : lien. Il s'agit de la feuille de style du site de Cream-Browser.
Il vous faudra pour cela installer Sass 3 via gem :
$ gem install haml --pre
Ensuite il vous suffit d'utiliser l'executable Sass pour compiler vos fichier SCSS :
$ sass style.scss style.css
$ sass --watch style.scss:style.css
$ sass --watch scss:stylesheets
Convert a single file to SCSS syntax
$ sass-convert --from sass2 style.sass style.scss
Convert all files to SCSS syntax
$ sass-convert --from sass2 --to scss --recursive .
Pour plus d'info : Intro à SCSS pour les utilisateurs de Sass - Site officiel
Bonjour,
Je vous accueille aujourd'hui avec un article sur LVM2, merveille que je vais vous présenter sur le champ.
LVM, signifiant Logical Volume Manager, permet de concatener plusieurs partitions en une seule. Par exemple, vous avez 2 disques dur de 20Go. Vous faites trois partitions :
Vous créez un Physical Volume pour chaque partition comme ceci :
# pvcreate /dev/sda3 /dev/sdb1
Physical volume "/dev/sda3" successfully created
Physical volume "/dev/sdb1" successfully created
Nous allons maintenant concaténer ces volumes physiques dans un groupe de volume :
# vgcreate myVG /dev/sda3 /dev/sdb1
Volume group "myVG" successfully created
La commande vgdisplay affichera toute les informations sur vos Volume Group.
Nous allons maintenant créer un volume logique sur lequel nous créerons notre partition :
# lvcreate -n myLV1 -L 38G myVG
Logical volume "myLV1" created
La taille de /dev/sda3 est de 18Go, celle de /dev/sdb1 est de 20Go, on veut concatener nos disques ce qui donne une taille de 38Go. Nous créons ce volume logique dans le groupe de volume "myVG" (qui est la concaténation de /dev/sda3 et /dev/sdb1)
Il ne reste plus qu'a créer votre troisième partition monté sur / :
# mkfs -t xfs /dev/myVG/myLV1
ou
# mkfs -t xfs /dev/mapper/myVG-myLV1
NB: S'il reste de la place sur vos disques vous pouvez bien entendu créer d'autre volume logique.
Bon, vous venez d'acheter un troisième disque dur de 20Go que vous avez ajouté. Et vous avez créé une partition unique dessus que vous souhaitez ajouter à votre partition pour obtenir une taille de 58Go :
# pvcreate /dev/sdc1
Physical volume "/dev/sdc1" successfully created
# vgextend myVG /dev/sdc1
Volume group "myVG" successfully extended
Nous venons de créer un nouveau volume physique et de l'ajouter à notre groupe de volume
Il ne nous reste plus qu'à agrandir la taille du volume logique et du système de fichier :
# lvextend -L +20G /dev/myVG/myLV1
Extending logical volume myLV1 to 58,00 GB
Logical volume data01 successfully resized
# resize2fs /dev/myVG/myLV1
NB: Ceci peut être fait à chaud sans démonter le système de fichier
L'inverse est également possible, par exemple passer votre volume de 58Go à 50Go. Il vous faudra dabord réduire le système de fichier :
# fsck -f /dev/myVG/myLV1
# resize2fs /dev/myVG/myLV1 50G
Puis réduire le volume logique :
# lvreduce -L 50G /dev/myVG/myLV1
NB: Ceci ne doit absolument pas être fait à chaud, vous devez démonter le système de fichier avant de faire quoi que ce soit.
Ce n'est qu'un bref aperçu des possibilités de LVM2, il est également possible :
Notez qu'il existe des outils graphiques permettant de ne pas s'encombrer de la ligne de commande si celle ci vous repousse.
Bonjour,
Je vous annonce que le site de Cream-Browser a entièrement été refait (toujours en gardant le même thème).
Tout dabord, j'ai passé le code en PHP (le code HTML étant chiant à maintenir). J'ai ensuite remarqué que le bugtracker flyspray utilisant mysql était down. Je me suis donc lancé dans la rédaction d'un bugtracker home-made et parfaitement intégré au site (et beaucoup plus simplifié que flyspray).
J'ai donc commencé par créer un espace membre (s'inscrire). Vous pouvez vous inscrire en toute sécurité, les mots de passe sont chiffré à l'aide de MD5 et j'utilise la librairie reCAPTCHA pour la génération des captchas.
J'ai ensuite dynamisé la page Authors afin de répartir les membres inscrit dans les trois groupes : manager, developper, et packager. Cerise sur le gateaux, vous aurez un avatar défini à partir de votre addresse email grâce au site internet Gravatar. Allez donc vous inscrire dessus et y mettre votre avatar favoris :)
Viens enfin la création du bugtracker, la chose est simple, type (bug ou feature), status (ouvert, fermé, fixé), ID de l'utilisateur qui a reporté le bug, ID de l'utilisateur à qui il est assigné (par défaut -1 = unassigned), et le contenu. J'ai ajouté aujourd'hui la possibilité d'ajouter des commentaires aux bugs afin d'en discutter (la aussi très simple, id du bug, id de l'utilisateur, contenu du commentaire).
On pourra observer sur la page du membre les bugs qu'il a reporté et ceux qui lui sont assignés.
Après, pour le confort personnel, j'ai décidé de gérer les news du site (le petit paragraphe en bas de l'index) et les screenshots directement dans la BDD. Normalement je ne toucherai plus au code (ouf ^^). Ah si, pour la TODO list ^^"
Enjoy sur le nouveau site ;)
Comme le dit cet article, NixOS est probablement la seule distribution GNU/Linux fonctionnelle.
La distribution est basée sur le gestionnaire de paquet Nix, celui ci, qui est au coeur du système, propose bon nombre de fonctionnalité à s'en lécher les babines, on pourra citer par exemple :
La présence d'un arbre contenant la totalité des logiciels :
/nix/store/r8vvq9kq18pz08v249h8my6r9vs7s0n3-firefox-2.0.0.1/
Ce dossier contient la totalité des dépendances à firefox-2.0.0.1 et le programme en lui même. Ici r8vvq est le hash MD5 de l'arbre des dépendances. Ce qui affecte un identifiant unique à chaque paquet et permet à l'utilisateur d'installer plusieurs versions différentes d'un même logiciel le tout dans une transparence des plus complètes. Ce système sera également utilisé pour effectuer des downgrades complet du système (revenir à une ancienne version).
La gestion du multi-utilisateur, cela signifie donc qu'un utilisateur ne possédant pas les privilèges administrateur peut installer un programme dans l'arbre sans l'ajouter au PATH global (uniquement au PATH utilisateur). Si le logiciel installé a déjà été installé par un autre utilisateur, alors celui-ci ne sera pas retéléchargé/compilé et sera tout simplement ajouté au PATH utilisateur. En même temps il est impossible pour un utilisateur d'injecter un trojan dans un paquet qui pourrait être utilisé par un autre utilisateur.
Les rollbacks. Ici on notera une fois de plus l'avantage des hash MD5. Ils permettent à l'utilisateur d'effectuer un retour en arrière dans le système (les downgrades dont je vous ai parlé) :
état 1
$ nix-env --upgrade some-packages
état 2
$ nix-env --rollback
Nous revoila à l'état 1
Les patchs binaires. Vous connaissez surement les patchs (utilisés par la plupart des gestionnaires de version comme git) généré par exemple par le programme diff. Ici le principe est le même mais il s'applique sur les fichiers binaires. Cela permet donc un téléchargement des mise à jour bien plus rapide et une installation quasi-instantanné (dépendant de la taille du programme à patcher)
Et bien d'autres, je vous invite à visiter cette page pour plus d'infos.
Je vous l'ai dit plus haut, Nix est au coeur du système, c'est lui qui compile tout les logiciels, ainsi que le noyau et il génère la configuration (généralement situé dans /etc). Ceci permet donc d'avoir plusieurs configurations possible, d'effectuer à nouveau les rollbacks du système de base complet, ou bien d'utiliser le langage de script Nix. Voici un exemple :
{
boot.loader.grub.device = "/dev/sda";
fileSystems = [
{ mountPoint = "/";
device = "/dev/sda1";
}
];
}
Après avoir modifié /etc/nixos/configuration.nix, vous pouvez mettre à jour la configuration en lançant cette commande :
$ nixos-rebuild switch
Et pour revenir en arrière :
$ nixos-rebuild switch --rollback
Cependant la distribution vous permet de reconstruire tout la configuration sans l'établir comme configuration par défaut, ce qui vous permettera de tester vos modifications :
$ nixos-rebuild test
Au démarrage suivant, vous avez votre ancienne configuration, vous pouvez cela dit tester tout cela en demandant la compilation et le lancement d'une machine virtuelle :
$ nixos-rebuild build-vm
$ ./result/bin/run-*-vm
Ceci démarre une machine virtuelle contenant la nouvelle configuration (une copie de la configuration de l'hôte avec toute les modifications que vous y avez faites). La machine virtuelle ne partage aucune donnée avec l'hôte, vous pouvez donc y faire tout vos test expérimentaux dedans.
Encore une fois, je vous invite à lire cette page pour plus d'informations.
... qui sont mis à votre disposition. Une multitude ? Environ 2500 à l'heure actuelle supportant les platformes suivantes :
Voici la page officielle de Nixpkgs.
Vous pourrez trouver toutes les informations nécéssaire à ce lien.
Je vous souhaite bon amusement avec cette distribution plus que prometteuse :)
Bonjour,
Sur la majorité des systèmes, le compilateur par défaut n'est autre que gcc. Cependant le projet LLVM, visant à créer une suite de compilateur bytecode générant ainsi des executables portables sur tout système doté de LLVM, se dote d'un sous-projet : Le projet clang
clang est un compilateur des langages de la famille du C (le C, le C++, l'Objective-C, le C#, etc...). Mais pourquoi l'utiliser lui et non gcc ?
On notera ensuite une sortie plus expressive que GCC :
$ gcc-4.2 -fsyntax-only t.c
t.c:7: error: invalid operands to binary + (have 'int' and 'struct A')
$ clang -fsyntax-only t.c
t.c:7:39: error: invalid operands to binary expression ('int' and 'struct A')
return y + func (y ? ((SomeA.X + 40) + SomeA) / 42 + SomeA.X : SomeA.X);
~~~~~~~~~~~~~~ ^ ~~~~~
Il est également compatible avec GCC, c'est à dire qu'il gère les extensions de ce compilateur ajouté au langage (étant majoritairement utilisé par les développeurs qui ne veulent uniquement que leurs codes compilent)
C'est un compilateur vraiment performant et qui mérite grande attention :)
Hier sur le salon IRC de Cream-Browser (je le rappelle : #cream-browser @ irc.freenode.net ) quelqu'un m'a dit ceci :
Salon IRC: 20:58 < _nathan> linkdd, tu avais vu ça "GNet is maintained, but not developed any further. You should not use it in new software." 20:58 < _nathan> ? 20:59 < linkdd> non 21:08 < _nathan> linkdd, maintenant si
Je ne pouvais donc pas utiliser une librairie qui n'est plus développé dans Cream-Browser ! J'ai donc décidé de recoder moi même ce pourquoi je l'utilisais, soit :
C'est donc la librairie GNet qui s'en va !
Mais je n'en reste pas la ! En effet j'en ai profité pour supprimmer l'objet CurlClient en prévision de la prochaine inclusion du FtpClient fait main, ce qui signifie que actuellement le FTP est indisponible dans Cream-Browser (ce n'est que temporaire cela dit).
Curl, je n'ai plus besoin de toi :)
Les autotools sont des outils développé par le projet GNU permettant de configurer un projet et de générer les Makefiles permettant la compilation du dis projet.
C'est donc l'association de différents programes :
Chaque fichier à son importance :
Après le passage de aclocal, et de automake nous avons donc :
Ensuite nous avons le passage d'autoconf :
Voici un bref exemple :
configure.ac :
AC_INIT ([amhello], [1.0], [bugâreport@address])
AM_INIT_AUTOMAKE([âWall âWerror foreign])
AC_PROG_CC
AC_CONFIG_HEADERS([config.h])
AC_CONFIG_FILES ([
Makefile
src/Makefile
])
AC_OUTPUT
Makefile.am :
SUBDIRS = src
src/Makefile.am :
binPROGRAMS = hello helloSOURCES = main.c
Voici un tutoriel (en anglais) pour apprendre à maitriser pleinement les autotools
Bonjour,
Vous pouvez désormais observer la deuxième monture de pblog, encore en développement et contient encore quelques bugs. Cela dit c'est toujours fidèle à l'ancien, rapide et efficace.
La gestion des base de données est désormais faites avec SQLAlchemy qui permet plus de stabilité/rapidité et on a accès à une interface d'administration en ligne, c'est le bonheur :D L'installation se fait graphiquement, et un champ permet de récupérer tout les articles/commentaires d'un pblog1 pour une migration invisible à l'internaute (avouez que vous n'aviez rien vu ;) )
Bref je vous laisse aller le télécharger et le tester :
$ git clone git://git.philpep.org/pblog2.git
Bonne chance ;)
Doxygen est un outil extrêmement performant qui vous permettera de générer une documentation de votre code source relativement rapidement.
Le principe est simple, vous rédigez votre documentation dans les commentaires de vos sources. Vous lancez doxygen. Il va scanner le code, détecter les commentaires et générer la documentation dans les formats suivants :
Vous pouvez observer un exemple ici même : http://doc.cream-browser.net/
Voici un exemple complet de documentation en C (tiré du tutoriel sur developpez.com) :
/**
* \file main.c
* \brief Programme de tests.
* \author Franck.H
* \version 0.1
* \date 6 septembre 2007
*
* Programme de test pour l'objet de gestion des chaînes de caractères Str_t.
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/**
* \struct Str_t
* \brief Objet chaîne de caractères.
*
* Str_t est un petit objet de gestion de chaînes de caractères.
* La chaîne se termine obligatoirement par un zéro de fin et l'objet
* connait la taille de chaîne contient !
*/
typedef struct
{
char * sz; /*!< Chaîne avec caractère null de fin de chaîne. */
size_t len; /*!< Taille de la chaîne sz sans compter le zéro de fin. */
}
Str_t;
/**
* \enum Str_err_e
* \brief Constantes d'erreurs.
*
* Str_err_e est une série de constantes prédéfinie pour diverses futures
* fonctions de l'objet Str_t.
*/
typedef enum
{
STR_NO_ERR, /*!< Pas d'erreur. */
STR_EMPTY_ERR, /*!< Erreur: Objet vide ou non initialisé. */
NB_STR_ERR /*!< Nombre total de constantes d'erreur. */
}
Str_err_e;
/**
* \fn static Str_err_e str_destroy (Str_t ** self)
* \brief Fonction de destruction de l'objet Str_t.
*
* \param self Adresse de ll'objet Str_t à détruire.
* \return STR_NO_ERR si aucune erreur, STR_EMPTY_ERR sinon.
*/
static Str_err_e str_destroy (Str_t ** self)
{
Str_err_e err = STR_EMPTY_ERR;
if (self != NULL && *self != NULL)
{
free (* self);
*self = NULL;
err = STR_NO_ERR;
}
return err;
}
/**
* \fn static Str_t * str_new (const char * sz)
* \brief Fonction de création d'une nouvelle instance d'un objet Str_t.
*
* \param sz Chaîne à stocker dans l'objet Str_t, ne peut être NULL.
* \return Instance nouvelle allouée d'un objet de type Str_t ou NULL.
*/
static Str_t * str_new (const char * sz)
{
Str_t * self = NULL;
if (sz != NULL && strlen (sz) > 0)
{
self = malloc (sizeof (* self));
if (self != NULL)
{
self->len = strlen (sz);
self->sz = malloc (self->len + 1);
if (self->sz != NULL)
{
strcpy (self->sz, sz);
}
else
{
str_destroy (& self);
}
}
}
return self;
}
/**
* \fn int main (void)
* \brief Entrée du programme.
*
* \return EXIT_SUCCESS - Arrêt normal du programme.
*/
int main (void)
{
Str_err_e err;
Str_t * my_str = str_new ("Ma chaine de caracteres !");
if (my_str != NULL)
{
printf ("%s\n", my_str->sz);
printf ("Taille de la chaine : %d\n", my_str->len);
err = str_destroy (& my_str);
if (! err)
{
printf ("L'objet a ete libere correctement !\n");
}
}
return EXIT_SUCCESS;
}
Avant de lancer la génération de la documentation, il faut configurer le programme à travers un fichier de configuration, le fichier Doxyfile. Bien évidement il peut paraitre complexe à prendre en main au premier abord, c'est pourquoi il existe le programme : doxywizard.
Je vous inviterai à lire ce tutoriel ainsi que la documentation sur le site officiel de Doxygen.
Cependant Doxygen ne se limite pas à ca et possède plein d'autre fonctionnalité, couplé avec dot il permet de faire des graphique dans la documentation des objets pour l'héritage etc...
Bref je vous laisse vous renseigner comme des grands ;)
Bonjour,
Jusque maintenant Cream-Browser était sous la licence GPL. Elle interdisait à quiquonque de distribuer le code sous une licence non-compatible à la GPL (c'est à dire une licence propriétaire par exemple).
Comment ? Une licence libre qui interdit quelque chose ? On n'a jamais vu ça ^^ J'ai donc décidé de déposer mon logiciel sous la licence MIT, licence créée par le Massachusetts Institute of Technology et aussi connu sous le nom de X11 License car utilisé pour le gestionnaire graphique X Window System.
Cette licence est similaire à la licence BSD sauf en un point : C'est une licence de logiciel libre et Open Source. Elle donne à toute personne recevant le logiciel le droit illimité de l'utiliser, le copier, le modifier, le fusionner, le publier, le distribuer, le vendre et de changer sa licence. La seule obligation est de mettre le nom des auteurs avec la notice de copyright.
Elle est donc compatible avec la licence GPL :)
Autre nouvelle au passage, je suis actuellement en train de coder un objet GFtp qui s'occupera de l'intégration du protocole FTP à l'aide de la librairie GNET (déjà en dépendance pour Gopher), cela me permetterai donc de supprimer la dépendance à Curl.
Cordialement, David Delassus.
Il y a quelque temps je vous ai parlé de WMFS dans ce billet. Un tiling WM extrêmement léger et très rapide.
WMFS connait une expansion dut à un arrivage massif d'utilisateur depuis quelque mois. Les features request sur le bug-tracker du site fusent. Notament quelques features venant d'autres tiling WM tel que wmii ou encore dwm.
WMFS gère désormais les images grâce à la librairie imlib2 (facultative à la compilation). Comment en afficher ? Et où ?
La réponse est simple, partout ou l'on peut afficher du texte (donc le menu, le layout, la statusbar, les tags, etc...). Pour cela il nous suffira de taper la séquence suivante :
\i[x;y;w;h;/path/to/your/image.ext]\
Et vous aurez une jolie image :D Voici un exemple : image dans le menu layout - menu layout + tags
Partout ou on peut afficher du texte, on peut y faire passer les séquences de caractères suivantes :
\#RRGGBB\ # Couleur héxadécimale
\s[x;y;#RRGGBB;your text]\ # Affiche "your text" de couleur #RRGGBB Ã la position (x;y)
\b[x;y;w;h;#RRGGBB]\ # Affiche un rectangle de couleur #RRGGBB, de largeur w et de hauteur h à la position (x;y)
\i[x;y;w;h;/path/to/your/image.ext]\ # Ca on connait :)
Une astuce a été donné pour réaliser à l'aide de \b[]\ des progressbar :
calc()
{
echo "`echo $1 | bc -l | cut -d. -f1`"
}
progressbar()
{
local BARH=`calc "$8/$9*$3"`
local BORD="\b[`calc \"$1 - 1\"`;`calc \"$2 - 1\"`;`calc \"$3 + 2\"`;`calc \"$4 + 2\"`;$5]\ "
local BGBAR="\b[$1;$2;$3;$4;$6]\ "
local VBAR="\b[$1;$2;$BARH;$4;$7]\ "
echo "$BORD$BGBAR$VBAR"
}
Pour y afficher du texte pardis !
Par défaut, WMFS affiche son numéro de version dans la barre de status. Si le fichier ~/.config/wmfs/status.sh est présent et executable, celui ci sera lancé. Faisons un petit tour dans la config
[misc]
status_file = "/path/to/your/status" # ceci permet d'utiliser un autre script que status.sh, pourquoi pas en python ? ou en C même (comme le mien :D)
status_timing = 2 # Le script/programme sera executé tout les 2 secondes, si 0 est spécifié, alors il ne sera lancé qu'une seule fois. A vous de faire la boucle !
[/misc]
Ah que feront nous sans les tags, qui nous permettent d'avoir X bureau sur un écran :D La nouveauté dans WMFS sont plusieurs features présente dans d'autre WM, que voici :
C'est du multi-tag extrêmement puissant, à tester pour en apprécier le gout !
Nous avons également la possiblité de cacher les tags qui n'ont aucun client d'ouvert (dans la possiblité d'y accéder quand même via les keybinds). Pour plus de place, que du bonheur :)
Et tout récement (aujourd'hui même) bien qu'encore instable. Nous avons l'apparition du taging dynamique. Celui-ci vous permettera d'ajouter/supprimer des tags sans devoir recharger WMFS pour reprendre en compte la configuration.
Il est évident que je ne peux tout lister, la liste serait trop longue. Je vous conseille donc de tester, et d'aprécier :)
Hum un petit mois d'inactivité sur le site. Mais rassurez vous, c'est pour revenir avec de bonnes nouvelles :)
Tout d'abord, le développement de Cream-Browser est en avance constante. Dans ce dernier mois j'ai pu ajouter les choses suivantes :
Les key-bindings et les sockets en marche permettent donc une très grande souplesse du navigateur et cela me permettera à l'avenir de faire de nombreux plugins.
Mais il reste encore beaucoup à faire, comme par exemple :
Tout ca pour dire que Cream-Browser devient enfin utilisable (pas pleinement comme Uzbl ou Firefox, loin de la, mais c'est déjà un début). Cependant, à partir de ce lund 19 jusqu'au mercredi 28 je serais en Allemagne avec le lycée et donc dans l'impossibilité de développer pour Cream-Browser.
Une dernière chose, le salon IRC à changé et est désormais sur le réseau Freenode : #cream-browser. Et le dépot git se trouve désormais uniquement sur github.
Bonjour,
Je vous parlais dans un ancien billet de GnuSrc, une distribution Linux que je construisais sur mon PC. Celle ci a été refaite, il s'agit désormais d'une LFS effectivement muni de pkgsrc, mais utilisant SysVInit et non openrc comme je l'avais prévu.
Tout marche sur des roulettes, j'ai suivi le livre LFS, puis BLFS, et j'ai ensuite compilé pkgsrc, tout marche pour le mieux !
Je n'ai pas installé Firefox afin de me booster dans le développement de Cream-Browser (avec lequel ce billet a été écrit)
PyGitWeb est une interface web pour le gestionnaire de version Git (développé par Linus Torvald). Cette interface est, comme son nom l'indique, développé en Python.
Voici les différents billets que l'auteur a publié sur son blog :
Je suis ce projet avec attention car il est toujours complexe de mettre en place une interface web avec git (contrairement à mercurial) tel que gitweb ou cgit.
Bonjour,
Récement j'ai découvert, grâce à rhaamo, le protocole gopher. Il voulait que je l'implémente dans Cream-Browser (chose qui va s'avérer très simple).
Ce protocole est un ancêtre de HTTP, puis est devenu une alternative. Vous n'avez plus une page HTML avec des liens HTTP mais un "répertoire" avec une liste de fichiers et sous-dossiers. Chose que j'ai trouvé réellement pratique. Je vous invite à lire l'article sur wikipédia).
De plus la création d'un client est simplissime :
- Connexion au serveur sur le port 70
- Le serveur accepte la connexion mais ne dit rien
- Le client envoie une commande terminé par un CRLF ( "\r\n" )
- Le serveur envoie le résultat et ferme la connexion
Si votre commande est : "\r\n", le serveur va vous envoyer la liste des fichiers à la racine du site, si vous envoyez "/Books\r\n", il vous retournera la liste des fichiers du dossier /Books.
Vous pouvez identifier le type des fichiers par le premier caractère de chaque ligne :
Bref le codage d'un client est simplissime et ce sera un atout supplémentaire dans Cream-Browser.
Bonjour,
Ayant changé d'adresse email, j'ai du passer du temps à mettre à jour les copyrights présent dans chacun des fichiers de mes différents projets (juste au dessus des licences BSD/GPL). Mais également sur les comptes que je possède, comme :
J'ai donc par la même occasion mis à jour le site présent sur ce compte SourceForge pour ensuite le transférer sur ce serveur et acheter un nom de domaine, je vous invite à le visiter : http://cream-browser.net
Etant donné que j'ai repris le code de 0 pour repartir sur une base propre, le navigateur n'est pas encore utilisable, mais je bosse activement dessus (au lieu de travailler pour le lycée :-°) pour vous fournir un beau navigateur tout léger tout propre dans les plus bref délais :)
En ce moment je bosse sur une petite distribution linux perso que j'ai nommé GnuSrc.
Le but est donc de remplacer ma Debian pour une distribution qui me convient parfaitement. Sur les bons conseils de markand, j'ai décidé d'intégrer dans cette distribution plusieurs outils issus de NetBSD, notament le gestionnaire de paquets extrêmement performant : pkgsrc et le système d'init OpenRC.
Pour faire cours, voici de quoi est composé la distribution :
Pour l'instant elle n'est utilisable qu'en chroot et présente uniquement sur mon disque dur externe, donc ne vous réjouissez pas trop vite ;)
Il y a de cela quelque mois, j'avais entrepris le développement d'un navigateur internet simple et léger : Cream-Browser. Le principe était simple :
Seulement le projet s'abandonne petit à petit (allez savoir pourquoi). C'est donc un email d'un utilisateur, ainsi que l'insistance de certain amis sur IRC qui m'ont redonné l'envie de reprendre ce projet.
J'ai donc décidé de le reprendre de 0, le rendre beaucoup plus souple et stable, avec une base bien propre. J'ai donc décider d'implémenter ceci :
Voici un schéma du navigateur comme je l'ai pensé : lien
Je vais vous parler aujourd'hui du gestionnaire de fenêtre (window manager, soit wm) que j'utilise courrament. Il fait parti de la catégorie des tiling wm.
Les wm classiques vous laissent manipuler vos fenêtres vous meme, vous les placez ou vous voulez et les redimensionnez comme vous le souhaitez. Le tile va cependant placer et redimensionner automatiquement vos fenêtres en un tableau, le layout de tile. Il existe plusieurs layout différent, dont le plus commun et celui ou vous avez une grande fenêtre (la master) sur la gauche, et plusieurs petites fenêtres (les tile) sur la droite.
WMFS possède plusieurs layout, qui permettent de placer les tile un peu nimporte ou sur votre bureau selon votre gout (en haut, en bas, à gauche, à droite, des deux cotés, pas de fenêtres master, etc...). Ainsi il s'adapte à de nombreux utilisateurs, preuve de sa grande souplesse. Il possède également une fonctionnalité, le abovefc permettant de placer la fenêtre focus par dessus toutes les autres à 75% de la taille de l'écran et ce dans tout les layouts, contrairement à awesome qui ne le propose que dans son layout magnifier.
Son fichier de configuration est relativement simple, au pire un petit tour sur le cannal IRC et vous trouverez de l'aide facilement. WMFS intègre également une fonction permettant d'afficher ce que vous désirez dans votre barre de status via le script ~/.config/wmfs/status.sh pouvant donner des choses comme ceci : screenshot
Voici par exemple mon bureau sous WMFS : screenshot
C'est donc le 2 janvier 2010 à 0h09 que la version 1.0 de pblog est sortie. La première version stable, pleinement utilisable.
Je le rappelle, pblog est le moteur de blog développé en python par ksh dont les designs sont réalisés par Bender utilisé pour ce blog ci. Comme vous le voyez il est relativement simpliste mais pas moins efficace.
Les nouveautés sont les suivantes :
Je vous propose donc un lien pour le télécharger :
Enjoy ;)
En C l'utilisation de sprintf() ou snprintf() requiert une taille prédéfini pour dupliquer votre chaîne. Chose que le développeur ne connait pas forcément, dut peut-être à une entrée utilisateur n'ayant pas de taille prédéfini que l'on inclu dans notre chaine.
Il existe pour cela deux fonctions : asprintf() et vasprintf() qui vont allouer la chaîne pour y écrire la chaine formatté.
int asprintf (char **_ptr, char *fmt, ...);
int vasprintf (char **_ptr, char *fmt, va_list _varg);
Comment ses fonctions marchent-elles ? Comment récupèrent-elles la taille de la chaîne formatté ? La solution est bien simple, tournons nous du côté de la fonction vsnprintf().
Lisons un peu le manuel :
Les fonctions snprintf() et vsnprintf() n'écrivent pas plus de size octets (y compris le \0 final). Si la sortie a été tronquée à cause de la limite, la valeur de retour est le nombre de caractères (sans le \0 final) qui auraient été écrits dans la chaîne s'il y avait eu suffisamment de place.
Parfait ! Il suffit donc de faire un appel à vsnprintf() en passant les arguments de notre fonction vasprintf(), ainsi on récupère la taille de la chaîne. Il nous reste plus qu'à allouer et recopier la chaîne à nouveau avec l'appel de vsnprintf().
Voici donc le code :
int vasprintf (char **ptr, const char *fmt, va_list args)
{
int ret = 0;
char tmp = 0;
if (ptr == NULL) /* petite sécurité pour éviter les segfaults */
return -1;
/* On récupère 1 caractère de notre chaine préformaté,
* vsnprintf() va lire la chaine complète et retourner
* le nombre de caractère lu, donc la taille de la chaine
*/
ret = vsnprintf (&tmp, 1, fmt, args);
*ptr = malloc (ret * sizeof (char)); /* on alloue notre chaine avec la taille précédement récupéré */
/* on vérifie que l'allocation c'est faite correctement */
if (*ptr == NULL)
return -1;
/* et on duplique la chaine à l'aide de vsprintf() */
ret = vsprintf (*ptr, fmt, args);
return ret;
}
/* Ici il suffit d'appeler vasprintf() qui fait tout le boulot */
int asprintf (char **ptr, const char *fmt, ...)
{
va_list args;
int ret = 0;
va_start (args, fmt);
ret = vasprintf (ptr, fmt, args);
va_end (args);
return ret;
}
Et voila vos fonction asprintf() et vasprintf() conforme POSIX. Enjoy ;)
Bonjour chers internautes.
Bienvenue sur ce nouveau blog propulsé par pblog, un moteur de blog codé en python à l'aide de webpy. Comme vous le voyez simple mais efficace :) La mise en production nous a donné du fil à retordre (problème de permissions, de dépendances et de configurations), mais tout cela a été résolu avec l'aide de ksh.
C'est donc avec plaisir que je rédige ce premier billet.
Je me nomme David Delassus, alias linkdd ou encore daweed. Je suis développeur depuis maintenant 3 ans, je maitrise quelques langages comme vous avez pu le voire sur ma page principale avec une nette préférence pour le C orienté système/bas-niveau. Je prone le logiciel libre et favorise l'utilisation des licences GNU GPL et BSD. Je consacrerai donc ce blog au logiciel libre en général et à la programmation.
Pour ce premier article je vais vous parler d'un système de ramasse miette en C. Cet article a été écrit à la base par ksh, je l'ai trouvé relativement simple et tellement pratique :)
Un ramasse-miette, de l'anglais garbage collector, est un système de recyclage automatique de la mémoire. Il est souvent utilisé dans les programmes cycliques comme par exemple un shell.
Le C n'en implémente pas comme le langage python. C'est pourtant un outil très util et indispensable dans la plupart des cas.
Ici l'astuce consiste à créer des fonctions wrapper pour free et malloc. Une fois que tous nos appels d'allocation et de libération de mémoire passent par eux il est facile de créer une structure de type pile qui empile l'adresse de chaque allocation pour ensuite tout libérer d'un coup à la fin du cycle.
Pour la gestion de la pile nous allons utiliser les fonctions très pratique du header standard sys/queue.h, étant différent selon les OS je vous conseil de l'embarquer dans votre projet.
Tout d'abord définissons et initialisons la pile :
typedef struct stack_s {
void *adr;
SLIST_ENTRY(stack_s) next;
} stack_s;
static SLIST_HEAD (, stack_s) mstack = SLIST_HEAD_INITIALIZER (&mstack);
Il ne nous reste plus qu'a créer ensuite une fonction xmalloc() qui se chargera d'allouer la zone mémoire et d'empiler l'adresse sur notre pile :
void *xmalloc (size_t size)
{
void *ret;
stack_s *el; /* l'élément à ajouter dans la pile */
ret = malloc (size); /* on alloue normalement */
if (!ret) /* Si l'allocation à échoué, on affiche l'erreur et on quitte */
{
perror ("xmalloc()");
exit (EXIT_FAILURE);
}
/* On ajoute l'addresse de l'allocation dans la pile */
el = malloc (sizeof (stack_s));
el->adr = ret;
SLIST_INSERT_HEAD (&mstack, el, next);
return ret; /* et on retourne l'addresse */
}
Ainsi nous pouvons allouer tranquillement nos pointeurs avec xmalloc() en début de cycle, mais désormais il faut désallouer, pour cela il suffit de vider la pile en passant l'adresse de chaque élément à free() :
void stack_delete (void)
{
stack_s *el;
while (!SLIST_EMPTY (&mstack)) /* tant que la liste n'est pas vide */
{
/* on récupère le premier élément que l'on supprime de la pile */
el = SLIST_FIRST (&mstack);
SLIST_REMOVE_HEAD (&mstack, next);
/* et on libère la mémoire */
free (el->adr);
free (el);
}
}
Il vous suffira désormais d'appeller cette fonction de temps en temps pour libérer la mémoire utilisé par votre programme, voici un exemple simple d'utilisation :
for (;;)
{
variable = xmalloc (sizeof (*variable) * 23);
/* suite de notre cycle */
stack_delete ();
}
Système plutot simple à mettre en oeuvre et assez rapide. Notez que vous pouvez également créer une fonction xfree() qui supprime directement l'élément de la pile, ici la fonction stack_delete() aurait plus un but de sécurité en cas d'oublie de libération de mémoire.
Suggestions
Flux RSS News
Twitter
Facebook
Google+
