[débat] Quel langage pour les "quick-hacks" ?

[anigel]

<trip=médiéval>
Oyez, oyez, braves contributeurs du forum Gentoo français,

Le printemps vient de naître, et voici venir le nouveau débat. Ce dernier fera cette fois l'objet d'une discussion que nous espérons éminemment constructive, et dans laquelle les preux chevaliers qui auront le courage de concourir pourront exposer, non seulement leurs arguments, mais aussi des exemples concrets d'applications, sous formes de scripts, de fichiers .profile, ou autres formes qu'ils jugeront utiles.

Les quick-hacks, keskecé ? Ben en fait c'est tout ce qui ressemble de près ou de loin à un mini-programme. vous avez programmé une fonction bash qui lance un encodage mplayer avec des paramètres passés en ligne de commande ? Bingo ! Vous avez un petit script qui trie les photos de votre appareil numérique pour les ranger dans des dossiers correspondants aux dates des photos ? Jackpot ! Etc... Ce sont souvent des .sh ou des .pl. Parfois c'est simplement quelques lignes dans un .bashrc ou un .profile. Mais dans tous les cas : si ça vous est utile, ça le sera certainement à d'autres ! Et, surtout, n'oubliez pas de dire pourquoi vous avez utilisé tel langage plutôt que tel autre, parfois on se borne bêtement à ce que l'on connait bien, alors... Rien de mieux qu'un bon exemple pour remettre les choses en perspectives !

Que la joute commence !
</trip>

[Trevoke]

Je me lance a l'eau le premier -- tout betement, ce qui nous est offert par defaut avec Gentoo : BASH script.

Exemples?
dans le .bashrc de root, un meilleur prompt :

Code: Select all

PS1="\n\[\033[35m\]\$(/bin/date)\n\[\033[32m\]\w\n\[\033[1;31m\]\u@\h: \[\033[1;34m\]\$(/usr/bin/tty | /bin/sed -e 's:/dev/::'): \[\033[1;36m\]\$(/bin/ls -1 | /usr/bin/wc -l | /bin/sed 's: ::g') files \[\033[1;33m\]\$(/bin/ls -lah | /bin/grep -m 1 total | /bin/sed 's/total //')b\[\033[0m\] -> \[\033[0m\]"

des petits alias:

alias mypretend="emerge --newuse --update --deep --pretend world"
alias myemerge="emerge --newuse --update --deep world"

Et puis, un jour, je voudrais maitriser sed et awk

[billiob]

Ca ne sert à rien, juste à faire beau au moment de se loguer :

Code: Select all

[0;01;31m                                           .
[0;01;31m     .vir.                                d$b
[0;01;31m  .d$$$$$$b.    .cd$$b.     .d$$b.   d$$$$$$$$$$$b  .d$$b.      .d$$b.
[0;01;31m  $$$$( )$$$b d$$$()$$$.   d$$$$$$$b Q$$$$$$$P$$$P.$$$$$$$b.  .$$$$$$$b.
[0;01;31m  Q$$$$$$$$$$B$$$$$$$$P"  d$$$PQ$$$$b.   $$$$.   .$$$P' `$$$ .$$$P' `$$$
[0;01;31m    "$$$$$$$P Q$$$$$$$b  d$$$P   Q$$$$b  $$$$b   $$$$b..d$$$ $$$$b..d$$$
[0;01;31m   d$$$$$$P"   "$$$$$$$$ Q$$$     Q$$$$  $$$$$   `Q$$$$$$$P  `Q$$$$$$$P
[0;01;31m  $$$$$$$P       `"""""   ""        ""   Q$$$P     "Q$$$P"     "Q$$$P"
[0;01;31m  `Q$$P"                                  """
[0;00;32m       +----------------------------------------> G N U \\ l  i  n  u  x      
[0;01;31m 
[0;01;34m This is \n.\O (\s \r) \d \t 
[0;01;34m         One 1667 MHz AMD Athlon(tm) XP 2000+ Processor,
[0;01;34m         512M RAM, 3301.37 Bogomips
[0;00m 

Si quelqu'un sait comment faire pour pouvoir changer la fin (One 1667 MHz AMD Athlon(tm) XP 2000+ Processor, 512M RAM, 3301.37 Bogomips) , en lisant /proc , je serais bien preneur.

Sinon, dans un autre genre, en BASH, pour lancer un jeu sur un autre serveur X (ici Enemy Territory) :

Code: Select all

#!/bin/bash
cd /opt/enemy-territory
/usr/bin/X11/numlockx on &&
export DISPLAY=:1  &&
#pour avoir la molette de la sourie fonctionnelle :
xmodmap -display :1 -e "pointer = 1 2 3 6 7 4 5 8 9 10 11" &
xinit /usr/games/bin/et-tcetest $* -- :1
setxkbmap fr

Ce script marchait parfaitement sous xorg<=7.0, mais depuis la version modulaire, j'ai des problèmes avec Xlib, et il ne marche que lancé depuis un "tty".

[gbetous]

Perso, je suis un adepte des bon vieux scripts, a base d'une foultitude de programme (grep, cut, sed, awk...)

Pourtant je pense que rien ne vaut un bon perl ou pytho pour faire ce style de truc... mais je m'y suis jamais trop penché

[anigel]

Si quelqu'un sait comment faire pour pouvoir changer la fin (One 1667 MHz AMD Athlon(tm) XP 2000+ Processor, 512M RAM, 3301.37 Bogomips) , en lisant /proc , je serais bien preneur.

Code: Select all

cat /proc/cpuinfo | grep "model name" | cut -d':' -f 2

Ce genre de trucs ?

EDIT : cat /proc/cpuinfo : affiche le contenu du fichier /proc/cpuinfo
grep "model name" : n'affiche que les lignes qui contiennent la chaîne "model name"
cut -d':' -f 2 : affiche la 2ème colonne de texte seulement, en utilisant ':' comme séparateur de colonnes

[billiob]

Code: Select all

cat /proc/cpuinfo | grep "model name" | cut -d':' -f 2

Ce genre de trucs ?

Le seul problème, c'est que ces lignes ne sont pas interprétées comme ça; c'est pas du bash, je ne sais pas comment mettre de commande (il ne prend que \O, \s ....)dedans . (J'essaierais quand même; Edit : ça ne marche pas , c'est interprété par agetty, donc à moins de refaire le /etc/issue à chaque fois, j'vois pas d'autre moyen. )
EDIT 2 : http://gentoo-wiki.com/TIP_Console_Prompt

[anigel]

Je n'avais pas fait attention au fait que tout ça était dans /etc/issue... J'avoue que je n'ai pas trop d'idées, car je présume que /etc/issue est lu, sans interprétation du code.. Par acquis de conscience, tu peux essayer de mettre ça entre back-quotes :

Code: Select all

cat /proc/cpuinfo | grep "model name" | cut -d':' -f 2

Mais, sans grand espoir..

[Trevoke]

On pourrait aussi executer le code et le storer dans /etc/issue a chaque lancement de l'ordi dans /etc/init.d/ ... Non?

[PabOu]

anigel : et un chat mort !!! encore ;) j'entends par là un "cat | grep" alors que grep tout seul fonctionne très bien dans ce cas.

ma contribution. Pourquoi du perl ? parceque je me suis basé sur un script déjà en perl :

Code: Select all

#!/usr/bin/perl -w
#
# wma2ogg.sh
#
# Transforme un .wma en .ogg grace à mplayer
# Nécessite de l'espace disque pour stocker le .wav temporaire
#
# la qualité du ogg de sortie est de 10 (paramètre -q 10)
#



use strict;

foreach my $file (@ARGV) {
next if ($file !~ /\.wma$/i);
my $base = $file; $base =~ s/\.wma$//i;
system "mplayer \"$file\" -ao pcm:file=\"$base.wav\"";
system "oggenc -q 10 \"$base.wav\" ";
unlink("$base.wav");
print "$base.wma converted to ogg.\n";
}

et un truc dans le même genre qui traine avec... ;)

Code: Select all

#!/bin/bash
#############################################################
# wma2mp3 v0.12
# by Calum and Void Main
#
# e.g. wma2mp3 myfile.wma
# e.g. wma2mp3 myfile.wma myfile2.wma myfile3.wma
# e.g. wma2mp3 "my file.wma" "my file 2.wma" "my file 3.wma"
# e.g. wma2mp3 *.wma
# e.g. wma2mp3 /directory/containing/wma/files
# e.g. wma2mp3 .
#
# http://voidmain.is-a-geek.net/forums/viewtopic.php?t=407
#
# History:
# 16 May 2003 - v0.1 wma2mp3 script created
# 27 August 2005 - v0.11 -aofile had been deprecated, corrected
# 28 August 2005 - v0.12 Added "IFS=" -Void
#############################################################

# Turn off input field separation so filenames with spaces work
IFS=

#############################################################
# Move the conversion process into a function that can
# be called.
# The "&&" makes it so each step must be successful before
# the next step will be done.
#############################################################

function wma2mp3 () {
  if [ ! -f "$1" ]; then
     echo "File $1 not found!"
  else
     mplayer -ao pcm:file="${1%%.[Ww][Mm][Aa]}.wav" "$1" &&
     lame -h -b 192 "${1%%.[Ww][Mm][Aa]}.wav" "${1%%.[Ww][Mm][Aa]}.mp3" &&
     rm -f "${1%%.[Ww][Mm][Aa]}.wav" ||
     echo "There was a problem with the conversion process!"
  fi
}

#############################################################
# Not enough information to compute
#############################################################
if [ $# -lt 1 ]; then
   echo "Syntax: `basename $0` <wmaFilename(s)|wmaDirectory>"
   exit
fi

#############################################################
# Directory was passed so convert all wma files in directory
#############################################################
if [ $# -eq 1 -a -d "$1" ]; then
  for file in $1/*.[Ww][Mm][Aa]
  do
    wma2mp3 "$file"
  done
  exit
fi

#############################################################
# One or more wma files were passed, convert them
#############################################################
for file in $*
do
  wma2mp3 "$file"
done
exit

je possède également (je m'en sers assez souvent par curiosité) le script pour mesurer la fragmentation d'une partition (ReiserFS only ?) créé par TGL, que vous pouvez retrouver ici

[Delvin]

Petite question, pour gérer, ces "quick-hack" on peut les mettre dans le repertoire, par exemple /bin/scripts, avec les droits root, et rajouter ce chemin dans le path de son user

ma question : est-ce qu'un user pourra les executer tranquillement ?

[TGL]

Perso, comme certains ont déjà pu le remarquer vu que j'en poste de temps en temps ici, j'utilise beaucoup Bash (plus ses amis type sed et compagnie) pour les p'tits scripts faits à l'arrache.

Grosso modo, ce que j'apprécie, c'est que ça se prête bien à une approche incrémentale. On peut faire des trucs déjà utiles et fonctionnels directement sur la ligne de commande, et c'est comme ça que ça commence en général, avec un simple "one-liner". Parfois ça en reste là (j'en fais juste un alias), et parfois ça grossit parceque je l'améliore petit à petit, et alors, pour l'éditer plus facilement, je le colle dans un fichier et je l'indente. Voilà, un script crade est né.
Éventuellement, si il mérite d'être partagé, je le nettoie et complète encore un peu jusqu'à en faire un vrai programme présentable, avec des options et tout et tout. Et aboutir ainsi à des "vrais programmes" en Bash, c'est possible : prenez media-sound/abcde par exemple, il est super bien fini, non ? Pourtant, je m'avance un peu mais je doute que son auteur visait, quand il a écrit la première ligne du code, à faire le rippeur de CDs ultime. À mon avis, il est plutôt parti de quelques one-liners à usage personnel, et il a brodé autour pour en arriver là.

Le deuxième langage que j'utilise pour les p'tits scripts, c'est Python. Par rapport à Bash et ses amis, l'inconvénient est qu'on doit tout de suite faire un "vrai" script, que c'est souvent plus verbeux pour des choses très simples en Bash/grep/sed/etc. Mais on gagne un langage plus puissant, avec notamment des structures de données difficiles à feindre en Bash. Donc selon les cas, on peut avoir :
- des oneliners bash/sed/etc. qui demandent 30 lignes de code pour être faits en Python ;
- des opérations simples de Python sur des structures complexes (des dictionnaires de listes de tuples, ou que sais-je), qui demande 10 lignes, 5 evals et 12 pipes pour être faits en Bash.

Et puis avec Python, on a accès à plein de modules super utiles pour éviter de réinventer la roue. Pour un gentooiste par exemple, un "import portage" vaut souvent bien des find, grep ou autre sed sur les fichiers de /usr/portage ou /var/db/pkg.

Bref pour moi, Python ou Bash, ça dépend des besoins... Je choisis plutôt Python quand je sens que les choses ne pourront pas rester simples bien longtemps au niveau des structures de données, ou quand j'ai besoin d'un module spécifique. Le pire évidemment, c'est de se planter sur ce choix et de se rendre compte qu'on doit recoder en Python un truc commencé en Bash.

Quant à Perl, je peux pas en dire grand chose, j'ai jamais vraiment appris. Mais du peu que j'en connais et des utilisations que j'en vois de ci de là, je pense que c'est un bon candidat pour concurrencer à la fois les scripts Bash et les scripts Python :
- l'accès aux fichiers texte et les opérations sur chaines de type grep/sed/etc. y sont beaucoup plus concises qu'en Python, donc il permet probablement de faire, sans exploser le nombre de lignes de code, ce que moi j'aurai tendance à faire en Bash.
- il se prête aussi assez très bien aux one-liners (comme Bash, et contrairement à Python).
- les structures de données complexes ou les modules utilitaires valent ceux de Python, donc là non plus, pas de soucis.
Bref, ça pourrait bien être le langage qui réconcilie tous les usages du quick hack, mais bon, je crois que je ne le saurai jamais avec certitude, parceque sa syntaxe n'est vraiment pas à mon goût, et que j'ai pas envie de faire des efforts pour apprendre un truc dont je n'ai pas réellement besoin (ayant déjà le Bash et le Python dans ma besace).


Et enfin, pour l'anecdote, récemment j'ai vu un utilisé OCaml pour un machin que typiquement moi j'aurais fait en Python :
http://www.linux-france.org/lug/gullive ... 00361.html
Et bah en fait, là ça s'y prêtait pas mal. Enfin je suis pas sûr que ça ait été le meilleurs choix possible non plus, mais disons que ça n'était pas complètement absurde : le programme est lisible (suffisament pour que j'envoie qlqs patchs à l'auteur alors que je n'avais pas fait d'OCaml depuis très longtemps), et pas trop long pour ce qu'il fait, donc bref, pourquoi pas...

[DaiKo]

Personnellement j'ai decouvert Python recement et j'adhere, c'est pas que je fasse souvent des scripts, mais quand cela m'arrive j'utilise python...

[bibi.skuk]

Et puis avec Python, on a accès à plein de modules super utiles pour éviter de réinventer la roue. Pour un gentooiste par exemple, un "import portage" vaut souvent bien des find, grep ou autre sed sur les fichiers de /usr/portage ou /var/db/pkg.

Tu aurait une adresse ou un moyen d'avoir un peu de doc a propos des fonctions de portage ??

pour ma part, j'utilise perl et bash... mais de plus en plus, je me dirige vers python, qui a l'avantage de pouvoir etre relu... par rapport au perl...

La plus part des scripts que j'ai fait tenait du one-liner, de temps en temps, je les garde pour y revenir plus tard, mais pas possible de se relire... (je haie le perl a cause de ca... je l'aime aussi pour la même raison, mais chut ;p)

[TGL]

Tu aurait une adresse ou un moyen d'avoir un peu de doc a propos des fonctions de portage ??

Code: Select all

% $EDITOR /usr/lib/portage/pym/*.py

Sérieusement, niveau documentation c'est pas trop ça, et tu te retrouves souvent à aller voir les sources pour trouver la fonction que tu cherches (évidemment, un éditeur qui y comprend qlqchose au Python, genre Vim ou Cream avec CTags, ou bien les GUI qui viennent avec wxpython, ça aide). Et puis les autres scripts existants, genre ceux de gentoolkit, peuvent aussi être de bon conseil.

Y'a ceci dit qlqs tentatives de documentation, mais rien qui soit complet ou bien maintenu à jour :
http://portage.wiki.gentooexperimental.org/
http://dev.gentoo.org/~kutsuya/

[kwenspc]

[mavie]
Moi c'est le python, surtout, et le bash
[/mavie]

Je trouve le python trés élégant et pour peu qu'on ai besoin de quelque chose de conséquent et de maintenable c'est un langage qui s'y prete bien.

Le bash je l'utilise surtout sur des scripts système comme pour parser rapido la sortie de la commande ps, ou autre.
Pour un problème vous avez une tonnes de solutions toutes aussi simples les unes des autres (bon ok vous pouvez faire trés compliqué aussi mais avec le bash c'est pas gagné)

Il va a l'essentiel quoi. En une ligne on peut faire un truc super compliqué et avoir un résultat époustouflant. (quelqu'un l'a déjà noté plus haut je crois)

[scout]

Bon alors moi j'utilise du bash, donc je ne vais pas en rajouter là dessus, et sinon du:
RUBY

Ruby est excellent, et contrairement à python on peux faire des one-liners, puisque ruby ne considère pas l'indentation.
irb est pour cela très pratique: on fait son one-liner progressivement et interactivement.
Le mécanisme des itérateur est excellent et les Array et compagnie ont 10000 méthodes utiles.
pour preuve sireyessire me parlais de code de césar l'autre jour.
Rappel: chaque lettre est changée pour une autre lettre "offset" plus loins dans l'alphabet.
par exemple si offset=2, alors a deviens c, b deviens d, ... x=>z, y => a, z=>b
Voilà ce que ça donne très rapidement:

Code: Select all

irb(main):001:0> str='coucou voici le truc a crypter'
=> "coucou voici le truc a crypter"
irb(main):005:0> offset=5; res=''; str.each_byte { |b| if b.chr==' ' then res << ' '; else res << ((b-?a)+offset)%26 + ?a; end }; res
=> "htzhtz atnhn qj ywzh f hwduyjw"
irb(main):006:0> offset=-5; str=res; res''; str.each_byte { |b| if b.chr==' ' then res << ' '; else res << ((b-?a)+offset)%26 + ?a; end }; res
=> "coucou voici le truc a crypter"

quelques explications:
l'itérateur each_byte itère sur la chaine et b deviens le byte du caractère considéré
?a c'est 97: le code ascii de a; donc quand je fais b-?a c'est le numéro de la lettre en partant de zéro pour la lettre a
on rajoute l'offset et on fait un modulo 26
on rajoute le code ascii de a avant de concaténer à la chaine résultat res avec l'opérateur <<
à la fin on affiche la chaine res

pour la décryption, on initialise str avec la valeur cryptée, et l'offset à -5.

Tout ça pour dire que j'aime bien faire des one liners en ruby; et je me sers très souvent de irb comme calculette

Autre exercice de style; la transformée de Burrows-Wheeler, que j'ai découvert en faisant un tour sur la page de bzip2 de wikipedia.
l'algorithme est expliqué ici: http://en.wikipedia.org/wiki/Burrows-Wheeler_transform
Je choisis le caractère 'Z' comme EOF (cf wikipedia) et je ne rentrerais que des chaines qui ne contiennent pas ce caractère
en ruby: (top chrono départ du codage à 20h05; fin à 20h20 sans les commentaires)

Code: Select all

#!/usr/bin/ruby -w

def rotate(str)
    return str[-1].chr+str[0..-2]
end

def codage(str)
    str=str+'Z' # str est modifié localement à la fonction
    table=[]
    1.upto(str.length) do
        table << str.scan(/./) # str.scan(/./) transforme la chaine str en tableau de caracteres isolés
        str=rotate(str)
    end
    return table.sort.transpose[-1].join
end

def decodage(str)
    str_caracteres_un_a_uns=str.scan(/./)
    table=[str_caracteres_un_a_uns].transpose
    1.upto(str.length-1) do # on fait la boucle de l'algo
        table=[str_caracteres_un_a_uns] + table.sort.transpose
        table=table.transpose
    end
    table.each do |str| # on cherche la ligne qui se termine par 'Z'
        if str[-1]=='Z'
            return str[0..-2].join()
        end
    end
end

voilà.
Ma méthode de dével: dans du vim, et périodiquement je fais:
w | irb -r rotate.rb
ce qui permet d'écrire les modifs du fichier, et de charger les fonctions dans irb pour pouvoir tester. (mon fichier s'appellait rotate.rb)
j'ai débuggé avec la fonction 'p' qui m'affiche la table de manière verbeuse.

exemple du irb -r rotate.rb:

Code: Select all

irb(main):001:0> codage('hello world of gentooists under gentoo on gentoo computers')
=> "onrfdosos lnhgggdto   Zorelooueeeool oc tttwmeoetriunnns p "
irb(main):002:0> decodage(codage('hello world of gentooists under gentoo on gentoo computers'))
=> "hello world of gentooists under gentoo on gentoo computers"

j'ai écrit plein de fois le mot 'gentoo' pour qu'on voie apparaitre l'intérêt de l'algo, à savoir transformer des répétitions de mots en répétitions de caractères consécutifs.

Voilà, c'était rigolo. J'ai pas essayé de tourner le truc en un machin incompréhensible au non rubyistes, et c'est du code que j'arriverais à relire dans 6 mois, contrairement à mes essais de perl. là je peux relire mes scripts ruby de décalage de sous titres et les comprendre parfaitement alors que ça fait un bail que je les ai écris. je sais qu'on peux écrire du perl propre, mais il y a juste que j'ai arrété d'apprendre le perl quand Sleeper m'a fait découvrir ruby (merci Sleeper )

[geekounet]

J'ai justement commencé à apprendre le ruby cet aprem, comme ça sur un coup de tête (non c'était pas trop douloureux )
Et merci scout, tu en rajoute à ma motivation, je suis encore plus convaincu que c'est le langage qu'il me faut

Sinon en ce qui me concerne, je ne scripte pas beaucoup, mais quand il faut c'est toujours en bash jusque là

[BuBuaBu]

Pour ma part, c'est php + bash.

Php peu paretre inatendu, mais il permet de faire rapidement une interface graphique pour des tache simple.

Par exemple remplir une crontab pour lancé mencoder.
Bien entendu mon utilisateur ne voit rien, et il se croi sur une magnetoscope par exemple.
Ok, c'est un peu lourd, il faut un serveur web et un naviguateur.

[PabOu]

ah non, tu peux utiliser du php en ligne de commande (cli).
tu dois compiler php avec le useflag cli.

plus d'infos ici.

Je pense que le php étant très facile (et d'une syntaxe proche du C parceque basé sur le C), il peut convenir à beaucoup de gens. Et puis, beaucoup de gens connaissent (un peu ou beaucoup) le php.

[mornik]

Perso j'utilise presque exclusivement bash. Et j'ai pas grand chose à proposer en script car je suis en ce moment entrain de me faire un script pour graver mes cd/dvd (data, iso, audio etc), car j'ai rien trouvé de bien convaincant dans ce domaine sauf k3b, mais comme ni qt ni kde sont installés sur ma machine...

[loopx]

Ca ne sert à rien, juste à faire beau au moment de se loguer :

Code: Select all

[0;01;31m                                           .
[0;01;31m     .vir.                                d$b
[0;01;31m  .d$$$$$$b.    .cd$$b.     .d$$b.   d$$$$$$$$$$$b  .d$$b.      .d$$b.
[0;01;31m  $$$$( )$$$b d$$$()$$$.   d$$$$$$$b Q$$$$$$$P$$$P.$$$$$$$b.  .$$$$$$$b.
[0;01;31m  Q$$$$$$$$$$B$$$$$$$$P"  d$$$PQ$$$$b.   $$$$.   .$$$P' `$$$ .$$$P' `$$$
[0;01;31m    "$$$$$$$P Q$$$$$$$b  d$$$P   Q$$$$b  $$$$b   $$$$b..d$$$ $$$$b..d$$$
[0;01;31m   d$$$$$$P"   "$$$$$$$$ Q$$$     Q$$$$  $$$$$   `Q$$$$$$$P  `Q$$$$$$$P
[0;01;31m  $$$$$$$P       `"""""   ""        ""   Q$$$P     "Q$$$P"     "Q$$$P"
[0;01;31m  `Q$$P"                                  """
[0;00;32m       +----------------------------------------> G N U \\ l  i  n  u  x      
[0;01;31m 
[0;01;34m This is \n.\O (\s \r) \d \t 
[0;01;34m         One 1667 MHz AMD Athlon(tm) XP 2000+ Processor,
[0;01;34m         512M RAM, 3301.37 Bogomips
[0;00m 

Heu, il y aurait moyen d'avoir plus d'info sur ce truc la, parce que ca m'intéresse... C'est généré automatiquement tout ca ? J'ai cherché dans google, mais j'ai pas trouvé de bon site, j'ai rien dans ce fichier /etc/issue a part la ligne que tu veux enlever...

[PabOu]

EDIT 2 : http://gentoo-wiki.com/TIP_Console_Prompt

loopx, je crois que c'est ca que tu recherches :)

[loopx]

Ouips, c'est bien ca que je cherche

[Pog]

hello hello,

ca ma donné une idée
enfin que j'ai piqué sur le wiki > ma source d'inspiration

dans mon ~/.bashrc

Code: Select all

cowsay -d `fortune -s bofh-excuses`

et op je me marre quand je me log sur le serveur de supervision

[xaviermiller]

Ca ne sert à rien, juste à faire beau au moment de se loguer :

Code: Select all

[0;01;31m                                           .
[0;01;31m     .vir.                                d$b
[0;01;31m  .d$$$$$$b.    .cd$$b.     .d$$b.   d$$$$$$$$$$$b  .d$$b.      .d$$b.
[0;01;31m  $$$$( )$$$b d$$$()$$$.   d$$$$$$$b Q$$$$$$$P$$$P.$$$$$$$b.  .$$$$$$$b.
[0;01;31m  Q$$$$$$$$$$B$$$$$$$$P"  d$$$PQ$$$$b.   $$$$.   .$$$P' `$$$ .$$$P' `$$$
[0;01;31m    "$$$$$$$P Q$$$$$$$b  d$$$P   Q$$$$b  $$$$b   $$$$b..d$$$ $$$$b..d$$$
[0;01;31m   d$$$$$$P"   "$$$$$$$$ Q$$$     Q$$$$  $$$$$   `Q$$$$$$$P  `Q$$$$$$$P
[0;01;31m  $$$$$$$P       `"""""   ""        ""   Q$$$P     "Q$$$P"     "Q$$$P"
[0;01;31m  `Q$$P"                                  """
[0;00;32m       +----------------------------------------> G N U \\ l  i  n  u  x      
[0;01;31m 
[0;01;34m This is \n.\O (\s \r) \d \t 
[0;01;34m         One 1667 MHz AMD Athlon(tm) XP 2000+ Processor,
[0;01;34m         512M RAM, 3301.37 Bogomips
[0;00m 

Heu, il y aurait moyen d'avoir plus d'info sur ce truc la, parce que ca m'intéresse... C'est généré automatiquement tout ca ? J'ai cherché dans google, mais j'ai pas trouvé de bon site, j'ai rien dans ce fichier /etc/issue a part la ligne que tu veux enlever...

et un bête

Code: Select all

man issue

ou

Code: Select all

man /etc/issue