Bash – Télécharger des scénarios de film

Pré-requis: Installer methabot

Création du répertoire qui va contenir les scénarios:
mkdir ~/moviescript && cd ~/moviescript

Extraction des urls:
for i in A B C D E F G H I J K L M N O P Q R S T U V W X Y Z ; do methabot -x :list http://web.archive.org/web/20030803234028/www.screentalk.biz/gallery${i}.htm | grep ".pdf" | sed -e '1d' >> scriptpdf.listing ; done

Téléchargement des scénarios (.pdf):
while read url; do wget $url; done < scriptpdf.listing

--2010-07-22 10:08:06--  http://web.archive.org/web/20030803234028/www.screentalk.biz/moviescripts/AceVentura.pdf
Résolution de web.archive.org... 207.241.227.60
Connexion vers web.archive.org|207.241.227.60|:80...connecté.
requête HTTP transmise, en attente de la réponse...

Bash – Manipulation date et heure

En théorie

Date

%a abréviation locale du jour de la semaine (Sun..Sat)
%A nom local du jour de la semaine (Sunday..Saturday)
%b abréviation locale du nom du mois (Jan..Dec)
%B nom local du mois (January..December)
%c date et heure locales (Sat Nov 04 12:02:33 EST
1989)
%d jour du mois (01..31)
%D date (mm/jj/aa)
%h comme %b
%j jour de l’année (001..366)
%m mois (01..12)
%U numéro de semaine dans l’année (00..53). La semaine
commence le Dimanche.
%w Jour de la semaine (0..6). Le 0 correspond au
Dimanche.
%W numéro de semaine dans l’année (00..53). La semaine
commence le Lundi.
%x représentation locale de la date (mm/jj/aa)
%y deux derniers chiffres de l’année (00..99)
%Y année (1970…)

Heure

%H heure (00..23)
%I heure (01..12)
%k heure ( 0..23)
%l heure ( 1..12)
%M minute (00..59)
%p notation locale pour AM ou PM.
%r heure actuelle (sur 12 heures) (hh:mm:ss [AP]M)
%s secondes écoulées depuis le 01-01-1970 à 00:00:00
T.U (extension non standard)
%S secondes (00..61)
%T heure actuelle, (sur 24 heures) (hh:mm:ss)
%X représentation locale de l’heure (%H:%M:%S)
%Z fuseau horaire (par ex. MET), ou rien si le fuseau
horaire n’est pas déterminé

Quelques exemples

Aujourd’hui

date ‘+%d-%m-%Y’
17-07-2009

date ‘+%d-%-m-%Y’
17-7-2009

date ‘+%d-%-m-%Y’
17- 7-2009

Hier

date ‘+%d-%m-%Y’ –date ’1 days ago’
16-07-2009

1 semaine en arrière

date ‘+%d-%m-%Y’ –date ’1 weeks ago’
10-07-2009

1 mois en arrière

date ‘+%d-%m-%Y’ –date ’1 months ago’
17-06-2009

Dans 96 jours

date ‘+%d-%m-%Y’ –date ’96 days’
21-10-2009

Générer une liste d’id unique basée sur le temps:

for i in $(seq 1 100); do sleep 1; date ‘+%s’  ; done
1247832772
1247832773
1247832774
1247832775
1247832776
1247832777
1247832778
1247832779
1247832780
1247832781
1247832782
1247832783

Bash – String contains

string='Ma chaine de caractère';

if [[ $string == *chaine* ]]
then
echo "hello string!";
fi

Binstats – L’inventaire de vos binaires

Outre le fait de combiner agilement plusieurs fonctions en une, binstats est un shell script qui vous dira quels sont les pauvres petits programmes orphelins foisonnants sur votre systèmes.

Vous aurez ainsi, le nombre d’exécutables classés par types (ELF, QMagic, liés statiquement, …) , les scripts, les binaires non strippés, setuid, partageant des libs absentes, le nombre de partages des libs, les libs inutiles et les packages qui en découlent.

Sous debian :

apt-get install binstats
binstats

Le résultat sera dans un fichier texte : binstats.log

Google dans sa coquille

goosh.org propose un shell pour faire vos recherches en ligne de commande.

Vu sur www.mfavez.com.

—————————————————————————————————-

Web

OSD – Afficher les prévisions météo sur son écran

Voila comment afficher les prévision météo sur son écran avec OSD (On Screen Display)

  1. Récupérer le flux RSS associé aux informations météo de votre région sur weather.com
  2. Afficher la météo via osd_cat
    Installer le paquet sudo apt-get install xosd-bin
  3. Créer un raccourci clavier dans le ~/.xbindkeysrc
    Installer le paquet sudo apt-get install xbindkeys

Pour ma ville, j’ai ajouté les 2 lignes suivantes dans mon .xbinkeysrc :

"wget 'http://fr.weather.com/rss-Vallauris-FRXX5403' -O /dev/stdout 2> /dev/null | grep '&deg;' | sed -e 's,&deg;C,°C,g' -e 's,.*CDATA\[\(.*\)\]\]>.*,\1,' | osd_cat -A left -p bottom -c green -o 330 -O 1 -f -*-helvetica-*-r-*-*-24-*-*-*-*-*-*-* -P 50 -d 8"
shift + F2

Appeler le raccourci clavier:
en appuyant sur les touches MAJ+F2, j’ai les prévisions météo qui s’affichent.

Sauvegarder un blog wordpress sur une clef usb

Objectif

Sauvegarder/Restaurer un blog de type WordPress:

  • sauvegarde des fichiers PHP
  • export SQL de la base de données

Langage de script utilisé: Bash

Script de Sauvegarde

wp-backupblog.sh

#!/bin/bash
# wp-backupblog.sh - Backup WordPress Blog
# version: 0.1
# Author: Benjamin Baudouin
# http://www.benjaminbaudouin.com
DEVICE=/dev/sda1
SRCDIR=/var/www/wordpress
USBKEYDIR=/media/usbkey/
TMPDIR=/tmp/backupblog/
ARCHIVE=blog.$(date +%Y%m%d).tar.gz
ARCHIVE_SQL=blog.$(date +%Y%m%d).sql
MYSQL_USER=root
MYSQL_PASS=*****************
MYSQL_DB=wordpress
#creation du repertoire tmp
if [ ! -e ${TMPDIR} ]
then
mkdir ${TMPDIR}
fi
#evaluation de la taille du blog
echo -e "Taille du blog (non compresse):"
du -sh ${SRCDIR}
#creation de l'archive (fichiers sources)
echo -e "Creation de l'archive ${ARCHIVE} ..."
cd ${SRCDIR}
tar cf - ${SRCDIR} | gzip > ${TMPDIR}${ARCHIVE}
echo -e "Taille du blog (archive compresse .tar.gz):"
du -sh ${TMPDIR}${ARCHIVE}
#creation de l'archive (fichier SQL)
echo -e "Creation de l'archive ${ARCHIVE_SQL} ..."
mysqldump -u${MYSQL_USER} -p${MYSQL_PASS} ${MYSQL_DB} > ${TMPDIR}${ARCHIVE_SQL}
echo -e "Taille du blog (archive .sql):"
du -sh ${TMPDIR}${ARCHIVE_SQL}
echo -e "Taille total blog"
du -sh ${TMPDIR}
#si pas d'automount, montage manuel
mount ${DEVICE} ${USBKEYDIR}
#copy
cp -rf ${TMPDIR} ${USBKEYDIR}
echo -e "\nCopie sur la clef usb ..."
#demontage
umount ${DEVICE}
if [ $? -eq 0 ]
then
echo -e "\nDone"
fi
exit 0

Script de Restauration

wp-restoreblog.sh

#!/bin/bash
# wp-restoreblog.sh - Restore WordPress Blog
# version: 0.1
# Author: Benjamin Baudouin
# http://www.benjaminbaudouin.com
DEVICE=/dev/sdb1
USBKEYDIR=/media/usbkey
BACKUPDIR=/media/usbkey/backupblog/
SRCDIR=/var/www/wordpress
SQLFILE=`find ${BACKUPDIR}*.sql`
MYSQL_USER=root
MYSQL_PASS=
#meme si pas d'automount, montage manuel
if [ ! -e ${USBKEYDIR} ]
then
mkdir ${USBKEYDIR}
fi
mount ${DEVICE} ${USBKEYDIR}
cp ${BACKUPDIR}*.tar.gz /
tar xzf /*.tar.gz
chown www-data:www-data ${
SRCDIR}
mysql -u${MYSQL_USER} -p${MYSQL_PASS} < ${SQLFILE}
umount ${DEVICE}


Accéder à la page projet

Bash – Raccourcis

tab   <--->   auto complétion pour les fichiers et les dossiers
^[chaîne 1]^[chaîne 2]^   <--->   lance la dernière commande en remplaçant la chaîne 1 par la chaîne 2
!-[n]   <--->   rappelle la commande lancée il y a n commandes
!!   <--->   lance la dernière commande
!?[chaîne]   <--->   lance la dernière commande terminant par la chaîne de caractères
!?[chaîne]?   <--->   lance la dernière commande contenant la chaîne de caractères
![chaîne]   <--->   lance la dernière commande commençant par la chaîne de caractères
![n°]   <--->   rappelle la commande n°... de l'historique
!#   <--->   lance la plus ancienne commande de l'historique
[commande] !^   <--->   lance la commande avec le premier argument de la commande précédente
[commande] !:[n]-[m]   <--->   lance la commande avec les arguments n à m de la commande précédente
[commande] !:[n°]   <--->   lance la commande avec l'argument n°... de la commande précédente
[commande] !$   <--->   lance la commande avec le dernier argument de la commande précédente
Alt + .   <--->   colle le dernier mot de la ligne précédente
Alt + b   <--->   déplace le curseur d'un mot vers la gauche
Alt + c   <--->   met en majuscule la lettre courante, en minuscules les autres lettres du mot courant, puis se place au mot suivant
Alt + d   <--->   efface le mot suivant
Alt + f   <--->   déplace le curseur d'un mot vers la droite
Alt + t   <--->   échange le mot courant et le mot précédent
Ctrl + _   <--->   Annuler les dernières modifications (rester appuyé)
Ctrl + a   <--->   déplace le curseur en début de ligne
Ctrl + c   <--->   envoie le signal SIGINT au processus en cours
Ctrl + d   <--->   efface le caractère courant, ou déconnecte (logout) si la ligne est déjà vide
Ctrl + e   <--->   déplace le curseur en fin de ligne
Ctrl + h   <--->   efface le dernier caractère
Ctrl + k   <--->   coupe tout à droite du curseur
Ctrl + l   <--->   efface l'écran (commande clear)
Ctrl + n   <--->   commande suivante (équivalent à la touche flèche bas)
Ctrl + o   <--->   exécute la commande (touche entrée)
Ctrl + p   <--->   commande précédente (équivalent à la touche flèche haut)
Ctrl + q   <--->   fait apparaître la saisie / relance l'affichage
Ctrl + r   <--->   recherche dans l'historique (Ctrl + r pour remonter à la chaîne précédente)
Ctrl + s   <--->   masque la saisie / arrête l'affichage (touche pause)
Ctrl + t   <--->   permet d'inverser deux lettres
Ctrl + u   <--->   coupe tout à gauche du curseur
Ctrl + w   <--->   coupe le mot à gauche du curseur
Ctrl + y   <--->   colle ce qui a été effacé à gauche du curseur (suite à un Ctrl + u)
Ctrl + z   <--->   passe le processus en cours en arrière plan
Echap, 10, A   <--->   répète 10 fois le caractère A
Echap, 5, Ctrl + q, Ctrl + v, 9   <--->   répète 5 fois le chiffre 9

Source
Autre article : bash-variables-speciales-tests-subsitutions-et-autres

Expect pour les rebonds ssh

Aprés un sudo apt-get install expect, voici le contenu du fichier ssh-bound :

#!/usr/bin/expect -f
# des que la chaine de caractère attendu en retour est matché,
# on attend 1 seconde et on envoit notre chaine
set timeout 1
# la 1ere commande qui est executée sur notre machine
# c'est le 1er saut
spawn ssh user@host1
# on "attend" du shell qu'il nous renvoit la chaine "assword"
expect "*?assword :"
# on envoit notre pw, \r pour retour chariot
send -- "MON_SUPER_PASS_EN_CLAIR\r"
# le prompt
expect "*05b\$ "
# 2eme saut
send -- "ssh user@host2\r"
expect "*?assword :"
send -- "MON_SUPER_PASS_EN_CLAIR\r"
expect "*05b\$ "
# 3eme saut#!/usr/bin/expect -f
# des que la chaine de caractère attendu en retour est matché,
# on attend 1 seconde et on envoit notre chaine
set timeout 1
# la 1ere commande qui est executée sur notre machine
# c'est le 1er saut
spawn ssh user@host1
# on "attend" du shell qu'il nous renvoit la chaine "assword"
expect "*?assword :"
# on envoit notre pw, \r pour retour chariot
send -- "MON_SUPER_PASS_EN_CLAIR\r"
# le prompt
expect "*05b\$ "
# 2eme saut
send -- "ssh user@host2\r"
expect "*?assword :"
send -- "MON_SUPER_PASS_EN_CLAIR\r"
expect "*05b\$ "
# 3eme saut
send -- "ssh user@host3\r"
expect "*?assword :"
send -- "MON_SUPER_PASS_EN_CLAIR\r"
expect "*05b\$ "
# expect nous rend la main
interact
send -- "ssh user@host3\r"
expect "*?assword :"
send -- "MON_SUPER_PASS_EN_CLAIR\r"
expect "*05b\$ "
# expect nous rend la main
interact

Source

Bash – Elément aléatoire d’un tableau


#!/bin/bash
tab=("a" "b" "c")
element=${tab[$RANDOM%${#tab[*]}]}
echo "$element"

Résultats aléatoires:
b
a
a
a
c

Bash – Variables spéciales, Tests, Subsitutions et Autres

Special Shell Variables
Variable Meaning
$0 Filename of script
$1 Positional parameter #1
$2 - $9 Positional parameters #2 – #9
${10} Positional parameter #10
$# Number of positional parameters
"$*" All the positional parameters (as a single word) *
"$@" All the positional parameters (as separate strings)
${#*} Number of command line parameters passed to script
${#@} Number of command line parameters passed to script
$? Return value
$$ Process ID (PID) of script
$- Flags passed to script (using set)
$_ Last argument of previous command
$! Process ID (PID) of last job run in background

* Must be quoted, otherwise it defaults to « $@« .

TEST Operators: Binary Comparison
Operator Meaning —– Operator Meaning
Arithmetic Comparison String Comparison
-eq Equal to = Equal to
== Equal to
-ne Not equal to != Not equal to
-lt Less than \< Less than (ASCII) *
-le Less than or equal to
-gt Greater than \> Greater than (ASCII) *
-ge Greater than or equal to
-z String is empty
-n String is not empty
Arithmetic Comparison within double parentheses (( … ))
> Greater than
>= Greater than or equal to
< Less than
<= Less than or equal to

* If within a double-bracket [[ ... ]] test construct, then no escape \ is needed.

TEST Operators: Files
Operator Tests Whether —– Operator Tests Whether
-e File exists -s File is not zero size
-f File is a regular file
-d File is a directory -r File has read permission
-h File is a symbolic link -w File has write permission
-L File is a symbolic link -x File has execute permission
-b File is a block device
-c File is a character device -g sgid flag set
-p File is a pipe -u suid flag set
-S File is a socket -k « sticky bit » set
-t File is associated with a terminal
-N File modified since it was last read F1 -nt F2 File F1 is newer than F2 *
-O You own the file F1 -ot F2 File F1 is older than F2 *
-G Group id of file same as yours F1 -ef F2 Files F1 and F2 are hard links to the same file *
! NOT (inverts sense of above tests)

* Binary operator (requires two operands).

Parameter Substitution and Expansion
Expression Meaning
${var} Value of var, same as $var
${var-DEFAULT} If var not set, evaluate expression as $DEFAULT *
${var:-DEFAULT} If var not set or is empty, evaluate expression as $DEFAULT *
${var=DEFAULT} If var not set, evaluate expression as $DEFAULT *
${var:=DEFAULT} If var not set, evaluate expression as $DEFAULT *
${var+OTHER} If var set, evaluate expression as $OTHER, otherwise as null string
${var:+OTHER} If var set, evaluate expression as $OTHER, otherwise as null string
${var?ERR_MSG} If var not set, print $ERR_MSG *
${var:?ERR_MSG} If var not set, print $ERR_MSG *
${!varprefix*} Matches all previously declared variables beginning with varprefix
${!varprefix@} Matches all previously declared variables beginning with varprefix

* Of course if var is set, evaluate the expression as $var.

String Operations
Expression Meaning
${#string} Length of $string
${string:position} Extract substring from $string at $position
${string:position:length} Extract $length characters substring from $string at $position
${string#substring} Strip shortest match of $substring from front of $string
${string##substring} Strip longest match of $substring from front of $string
${string%substring} Strip shortest match of $substring from back of $string
${string%%substring} Strip longest match of $substring from back of $string
${string/substring/replacement} Replace first match of $substring with $replacement
${string//substring/replacement} Replace all matches of $substring with $replacement
${string/#substring/replacement} If $substring matches front end of $string, substitute $replacement for $substring
${string/%substring/replacement} If $substring matches back end of $string, substitute $replacement for $substring
expr match "$string" '$substring' Length of matching $substring* at beginning of $string
expr "$string" : '$substring' Length of matching $substring* at beginning of $string
expr index "$string" $substring Numerical position in $string of first character in $substring that matches
expr substr $string $position $length Extract $length characters from $string starting at $position
expr match "$string" '\($substring\)' Extract $substring* at beginning of $string
expr "$string" : '\($substring\)' Extract $substring* at beginning of $string
expr match "$string" '.*\($substring\)' Extract $substring* at end of $string
expr "$string" : '.*\($substring\)' Extract $substring* at end of $string

* Where $substring is a Regular Expression.

Miscellaneous Constructs

Expression Interpretation
Brackets
if [ CONDITION ] Test construct
if [[ CONDITION ]] Extended test construct
Array[1]=element1 Array initialization
[a-z] Range of characters within a Regular Expression
Curly Brackets
${variable} Parameter substitution
${!variable} Indirect variable reference
{ command1; command2; . . . commandN; } Block of code
{string1,string2,string3,...} Brace expansion
{a..z} Extended brace expansion
{} Text replacement, after find and xargs
Parentheses
( command1; command2 ) Command group executed within a subshell
Array=(element1 element2 element3) Array initialization
result=$(COMMAND) Command substitution, new style
>(COMMAND) Process substitution
<(COMMAND) Process substitution
Double Parentheses
(( var = 78 )) Integer arithmetic
var=$(( 20 + 5 )) Integer arithmetic, with variable assignment
(( var++ )) C-style variable increment
(( var-- )) C-style variable decrement
(( var0 = var1<98?9:21 )) C-style trinary operation
Quoting
"$variable" « Weak » quoting
'string' ‘Strong’ quoting
Back Quotes
result=`COMMAND` Command substitution, classic style

Source

Bash – Split d’une chaine de caractères avec cut

data="bijoux;cailloux;choux;genoux;hiboux;joujoux;poux"

echo $(echo $data | cut -d";" -f1);
bijoux

echo $(echo $data | cut -d";" -f2);
cailloux

Recent Tweets

Catégories