Ce site est optimisé pour être consulté depuis un navigateur moderne dans lequel JavaScript est activé.

[ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

Nanoseb

@ Levi 59 :J'ai désactivé l'autologin pour pouvoir booter plus rapidement, du coup là j'ai un mot de passe et en plus je boot plus rapidement qu'avec le login classique. Mais c'est vrai que l’intérêt n'est pas extraordinaire, le but était aussi de me familiariser avec les script bash car je débute dans ce domaine.

YannUbuntu

Au fait, pour ceux qui aiment le Bash et veulent se rendre utiles, pouvez-vous jeter un oeil au code de Boot-Repair et m'indiquer ce qui peut être amélioré svp ?

le code peut être téléchargé ici: https://launchpad.net/~yannubuntu/+archive/boot-repair-dev/+packages

Merci pour votre aide 🙂

nordinatueur

Pour le mot de passe en clair, tu peux utiliser la somme md5 du mot de passe vu que tu le testes toi-même !

À la volée ça donnerait ça :

fichierSauvegardeMDP=~/.sauvegardeMDP.alert
Init ()
{
motDePasse1=0;
motDePasse2=1;
until [[ $motDePasse1 = $motDePasse2 ]]; do
    motDePasse1=$(zenity --entry --text "Entrez le mot de passe...") || exit;
    motDePasse2=$(zenity --entry --text "Répétez le mot de passe") || exit;
done;
md5sum <<<"$motDePasse1" >$fichierSauvegardeMDP;
}

if [[ -s $fichierSauvegardeMDP ]]; then
   pass=$(cat $fichierSauvegardeMDP)
   pass2=$(zenity --entry | md5sum );

   <le reste ne change pas...>

else
   Init ;
fi;

Je sais pas si c'est clair, mais l'idée est là...

EDIT : changer aussi « pass3 » en :

 pass3=$(zenity --entry | md5sum )

Nanoseb

Merci beaucoup je ne connaissais pas cette fonction, je vais étudier ceci de près.

nordinatueur

C'est la fonction qui est utilisée pour vérifier l'intégrité des fichiers ...
Le code que tu obtiens s'appelle la somme md5 et elle diffère complètement si tu ne changes ne serait-ce qu'un bit du fichier ! (voir entre autres http://doc.ubuntu-fr.org/md5sum)

En l'occurrence je l'utilise sur un fichier contenant uniquement le mot de passe ( modélisé par la redirection bash « <<< » et par le pipe après zenity.

Nanoseb

Merci pour ces précision, j'ai aussi lu l'article de wikipédia portant sur le md5, c'est très intéressant
Pour ceux que cela intéresse voici le script avec la parti de nordinateur :

#!/bin/bash
cd /home/chemin

if [ ! -f "log" ] 
then 
    echo ok >> log    
fi

fichierSauvegardeMDP=sauvegardeMDP
Init ()
{
motDePasse1=0;
motDePasse2=1;
until [[ $motDePasse1 = $motDePasse2 ]]; do
    motDePasse1=$(zenity --entry --text "Entrez le mot de passe...") || exit;
    motDePasse2=$(zenity --entry --text "Répétez le mot de passe") || exit;
done;
md5sum <<<"$motDePasse1" >$fichierSauvegardeMDP;
}

if [[ -s $fichierSauvegardeMDP ]]; then
    date=$(date +%d-%m-%y-%R:%S)
    pass=$(cat $fichierSauvegardeMDP)
    pass2=$(zenity --title="Bienvenue $USER" --password | md5sum ) 

    if [[ $pass = $pass2 ]]
    then 
        ok=1
    else
        pass3=$(zenity --title="Try again" --password | md5sum ) 
        if [[ $pass = $pass3 ]]
        then
            ok=1
        else
            ok=0
        fi
    fi

    if [ $ok = 1 ]
    then
        dernier=`tail -n 1 log`
        if [ $dernier != ok ]
        then
            echo ok >> log            
            display $dernier.png
        fi
    else
        mplayer tv:// -vo png -frames 3 -tv driver=v4l2
        rm 00000001.png 00000002.png
        mv 00000003.png $date.png
        echo $date >> log
        aumix -v 100
        mplayer alert.mp3
        dbus-send --system --print-reply  --dest=org.freedesktop.ConsoleKit /org/freedesktop/ConsoleKit/Manager  org.freedesktop.ConsoleKit.Manager.Stop
    fi


else
   Init ;
fi;

J'ai juste deux petites questions à propos de ton code, j'ai remarqué que tu mettais beaucoup de ";" en fin de ligne alors que je n'en mettait jamais auparavant, c'est juste par habitude ou ils ont une utilité ?
Et de même quel est l'intérêt de faire une fonction Init, puisque l'on ne s'en sert qu'une seule fois il ne serais pas plus simple de mettre ce code directement dans le else ?
Merci d'avance pour ces réponses

nordinatueur

Pour les points-virgules, c'est parce que j'utilise vim, et parfois pour clarifier certains passages du code j'utilise 'J' pour concaténer la ligne courante avec la suivante et les points-virgules sont obligatoire !
Ça me permet aussi de mieux voir les « vraies » fins de ligne par opposition aux fins comme then, do, ou encore dans un cat <<EOF ... et je vois alors mieux le code ainsi.
En bash ils sont inutiles en fin de ligne.

De la même façon, avec une certaine fonction vim qui corrige automatiquement, je mets des accolades autour de mes noms de variable même quand c'est inutile. C'est plus visuel... Ici comme je le disais j'ai écrit ça vite-fait sans tester...

En effet, ici pour la fonction il vaut mieux ne pas la définir. J'ai fait une fonction pour poster un bout de code sans trop y réfléchir. En général c'est très pratique de faire des fonctions, car on voit mieux l'intérêt des tests if... Sans ça on finit par ne plus se rappeler ce qui était testé quand on lit le else... En revanche, ici vu que le code est relativement petit il vaut mieux éviter. Quand on crée une fonction elle est chargée en mémoire, alors qu'on ne va peut-être pas l'utiliser... Ici c" n'est donc pas utile dans presque tous les cas (tous sauf un.) C'est donc du calcul, du temps et de la mémoire de perdus !

Dans ton code tu devrais mettre un cd « $HOME » au début, et cacher le fichier de mot de passe. C'est moins encombrant (mais c'est un avis personnel.) Ou alors encore mieux ! Tu pourrais carrément créer un dossier caché et tout y mettre ! Le fichier « log » et le fichier de mdp.

Nanoseb

Merci beaucoup pour toute ces réponses.
Et pour le cd, en faite sur le scripte dont je me sert j'ai fait un cd vers le dossier qui contient tout mes script et tout est enregistré là : capture, log et mdp.

Nanoseb

Alors me revoici avec un script un peut plus utile que celui de la dernière fois^^
Celui ci sert a notifier des mails, quand un mail arrive une notification s'affiche, un son se joue et le conky affiche une enveloppe

Il faudra mettre dans un dossier une image transparente, une représentant une envoloppe (ou autre) et un son de notification.
et ajouter une ligne de ce type dans votre conkyrc :

${image /home/seb/soft/mail/1.png -s 48x48 -p 314,149}

et enfin faire une tache cron avec ce script.

Dépendances : notify-send et mplayer

#!/bin/bash
chemin=$HOME/soft/mail
cd $chemin
username="username"  #username sans le "@gmail.com"
password="motdepasse"
wget https://"$username":"$password"@mail.google.com/mail/feed/atom

nbmail=`sed -n '/<fullcount>/,1 p' atom | sed 's/<fullcount>//' | sed 's/<\/fullcount>//'`
nbmailold=`sed -n '1 p' logmail`

if [ -z $nbmail ]
then
    nbmail=$nbmailold
fi

if [[ $nbmail != $nbmailold ]]
then    
    if [[ $nbmail > $nbmailold ]] 
    then
        titre=`sed   -n '/<title>/,1 p' atom | sed 's/<title>//' | sed 's/<\/title>//' | sed -n '2 p'`
        sujet=`sed -n '/<summary>/,1 p' atom | sed 's/<summary>//' | sed 's/<\/summary>//' | sed -n '1 p'`
        name=`sed -n '/<name>/,1 p' atom | sed 's/<name>//' | sed 's/<\/name>//' | sed -n '1 p'`
        notify-send "$name : $titre" "$sujet" -i $chemin/gmail.png
        mplayer dialog-question.wav
    fi
    
    echo $nbmail > logmail
        
    if [[ $nbmail > 0 ]]            #partie pour le conky
    then
        cp gmail.png 1.png
    else
        cp transparent.png 1.png
    fi
fi

rm atom

Je me doute bien que ce type de script doit déjà exister, mais c'était aussi un prétexte pour me familiariser avec sed, c'est pourquoi je ne sait pas si enchainer les | est très orthodoxe ^^, si vous avez quelque chose de plus jolie je suis prenneur.
De même si vous avez une idée pour que le mot de passe ne soit pas en clair cela m'intéresserais, j'avais pensée réutiliser les somme md5 mais je ne vois pas trop comment m'en servir dans ce cas.

Shrat

C'est génial! Merci!

nordinatueur

Salut !
Pour sed, tu peux remplacer

titre=`sed   -n '/<title>/,1 p' atom | sed 's/<title>//' | sed 's/<\/title>//' | sed -n '2 p'`

par

titre=$( sed -n '/<title>/s/<title>//;s/<\/title>//p' atom )

ou même :

titre=$( sed -n '/<title>/s,</\?title>,,gp' atom )

Il vaut mieux mettre tous les scripts-sed dans le « même sed » car en faisant des pipes tu augmentes le nombres de processus. Mes lignes n'en comptent qu'un, les tiennes en comptent quatre.
Surtout il faut préférer la syntaxe $( ... ) à l'ancienne dépréciée ` ... ` . C'est en tout cas ce que dit le manuel de bash.

Pour la partie avec les images, un lien symbolique serait mieux non ? Ça t'éviterait de copier une image à chaque fois...
Ça donnerait :

ln -s gmail.png 1.png

( Idem avec transparent.png )

Pour le mot de passe, il faudrait que ton script tourne en boucle infinie et que tu demandes le mot de passe au démarrage du script ... (avec zenity/yad ou en ligne de commande)
Mais de toute façon, dans ta requête

wget https://"$username":"$password"@mail.google.com/mail/feed/atom

le mot de passe apparaît en clair dans l'url. Et on peut donc le récupérer à coups de « ps x | grep atom » si on est patient...
J'étais passé par là il y a un certain temps et j'ai abandonné au profit d'applets pour les panels et pour les docks. J'ai même pensé à faire tout cela dans un petit programme en c (très banal, je n'y connais presque rien !) pour cacher un peu tout ça...

J'espère t'avoir aidé.

Nanoseb

Merci pour tout ces conseils,
Tout d'abord, ma commande sed prenais uniquement ce qu'il y avais dans la seconde balise <title> (d'où le | sed -n '2 p'), mais avec cette présentation je ne vois pas trop comment remettre ce bout de sed, j'ai essayé

$( sed -n '/<title>/s/<title>//;s/<\/title>//p;2 p' atom )

et d'autre truc sans succès.
ensuite pourrais tu m'expliquer ce que fait concrètement

sed -n '/<title>/s,</\?title>,,gp' atom

Et puis pour le mot de passe, comme rien n'est sécurisé, autant faire un cron qui sera je pense moins lourd qu'une boucle infinie.
Et encore merci pour tout tes messages, c'est vraiment sympa.

nordinatueur

Effectivement là je ne vois pas trop comment sed peut le faire...
(Pour l'instant ... je m'y pencherai quand j'aurai le temps.)

Pour la ligne

sed -n '/<title>/s,</\?title>,,gp' atom

Il y a deux choses nouvelles :
- La virgule est utilisé comme délimiteur. En fait la commande « s » de sed peut admettre tout caractère non-alphanumérique pour délimiteur. Même ceux qui ne sont pas visibles (@, !, tabulation, code ascii 1, code ascii 2, etc.)
- Si tu connais un peu les expression rationnelles, le « ? » que j'ai échappé avec un « \ » sert à dire que le caractère précédent apparaît au plus une fois. Cette expression rationnelle </\?title> vérifiera donc uniquement les chaînes <title> et </title>.
Remarque : Tu peux utiliser l'option -r de sed pour les caractères d'expression régulière ne doivent pas être échappés...

sed -n '/<title>/s=</\?title>==gp' atom
sed -nr '/<title>/s|</?title>||gp' atom

- L'option g demande que la substitution soit globale. Sans cette option sed n'opère que la première substitution et ne remplace pas </title>
- Enfin l'option p pour indiquer à sed d'imprimer le texte substitué. (Sans l'option -n les lignes originale ET substituée sont imprimées.)

Une solution que je n'apprécie pas vraiment, mais qui fonctionne en une ligne avec le script sed suivant :

:boucle;
    N;
    $!b boucle;
s/\n/\ /g;
s,<title>[^<]*</title>,,;
s,\([^<]\|<[^t]\|<t[^i]\|<ti[^t]\)*<title>\([^<]*\)</title>.*,\2,p;

Ou en une vraie ligne :

sed -ne ':boucle; N; $!b boucle; s/\n/\ /g; s,<title>[^<]*</title>,,; s,\([^<]\|<[^t]\|<t[^i]\|<ti[^t]\|<tit[^l]\|<titl[^e]\|<title[^>]\)*<title>\([^<]*\)</title>.*,\2,p;' atom

Pour être vraiment sûr de ne pas faire de bêtise, il faudrait affiner l'expression de la dernière substitution.
Avec toutes mes recherches depuis maintenant bien longtemps, je n'ai toujours pas réussi à interdire une chaîne de caractères simplement. La seule solution que j'ai trouvée consiste à épeler littéralement le mot qui est à interdire dans l'expression rationnelle.
Une autre façon d'épeler <title> est de dire qu'on ne veut pas de <, ou seulement s'il est suivit d'un caractère qui n'est pas un t, ou alors un t qui est suivi d'un caractère qui n'est pas un i ou un i qui ... Et les conditions s'imbriquent...
Voir ici, car le forum ne me permet pas de poster ces lignes...
Ce code qui est plus difficile à lire à l'avantage de faire, pour chaque caractère de la ligne, au plus N tests pour un mot de N lettres. Alors que le précédent en fait au moins N.

Je te conseille, lorsque tu écris un code avec sed, de le tester dans un script séparé avec une commande par ligne. Ensuite tu les regroupes toutes dans une seule ligne en mettant des « ; » entre les commandes (j'y prends l'habitude même en plusieurs lignes...)
Explication du script :
1- :boucle définit une « ancre » dans le script.
2- N indique à sed de mettre la ligne suivante à la suite de la première et de les séparer par \n
3- $!b boucle Si ce n'est pas ( ! ) la dernière ligne ( $ ), branche-toi ( b ) à l'ancre boucle.
4- s/\n/\ /g est une simple substitution...
5- s,<title>([^<]*)</title>,, supprimer le premier titre en supposant que le caractère < n'y apparaît pas.
6- Et enfin la dernière substitution, apporte la première occurrence restante de la balise <title>

Je te conseille, lorsque tu écris un code avec sed, de le tester dans un script séparé avec une commande par ligne. Ensuite tu les regroupes toutes dans une seule ligne en mettant des « ; » entre les commandes (j'y prends l'habitude même en plusieurs lignes...)
Explication du script :
1- :boucle définit une « ancre » dans le script.
2- N indique à sed de mettre la ligne suivante à la suite de la première et de les séparer par \n
3- $!b boucle Si ce n'est pas ( ! ) la dernière ligne ( $ ), branche-toi ( b ) à l'ancre boucle.
4- s/\n/\ /g est une simple substitution...
5- s,<title>([^<]*)</title>,, supprimer le premier titre en supposant que le caractère < n'y apparaît pas.
6- Et enfin la dernière substitution, apporte la première occurrence restante de la balise <title>

Merci à toi de partager tes initiatives ! C'est grâce à ça que ce forum avance et est une référence pour beaucoup de distributions...

nordinatueur

Bon en fait je viens juste de trouver beaucoup plus simple et pour le coup beaucoup plus rapide pour sed (même si on n'est pas à quelques microsecondes près...)
Voilà le script sed :

:boucle;
    N;
    $!b boucle;
s:<title>[^<]*</title>::;
s:<title>\([^<]*\)</title>.*:<title>\1:;
s:.*<title>::;

Lignes 1 à 3, on met tout sur une ligne !
Ligne 4, on supprime la première occurrence.
Ligne 5, on supprime tout ce qu'il y a après notre titre et on replace la balise <title> ou tout texte facilement identifiable (même avec des caractères non-imprimables sauf le caractère fin de fichier...)
Ligne 6, on se retrouve avec notre titre derrière la seule balise <title> (ou le texte choisi) et on supprime ce qu'il y a avant.

Nanoseb

Merci, je vais étudier ceci de près

nassertom

Bonjour,

J'ai fait ce script pour convertir des vidéos mkv en avi. la particularité de ce script est qu'il sélectionne automatiquement la langue française pour le fichier avi.
de plus pour les gens qui ont pas mal de fichier celui-ci vérifie la présence ou non du fichier avant de le ripper.

il effectue une recherche récursive dans le répertoire source (celui qui contient les mkv) ainsi que dans le répertoire cible (celui qui contient les avi)

J'ai fait cela cette nuit donc il est perfectible et si vous avec des propositions d'amélioration je suis preneur.
par exemple je n'ai pas réussi à lancer 2 conversions en simultané automatiquement et pour ce faire je lance 2 fois le scripts pour ripper 2 fichiers en même temps.
car les codecs que j'utilise via ffmpeg ne pas optimisé pour faire du multi-threads donc quite à travailler que sur un cœur autant lancer 2 scripts.

#!/bin/bash

if [ $# != 2 ] # Test le nombres de paramètre passé au shell
then
    echo erreur dans la saisie des paramètres;
    echo "essayer : sh $0 /repertoire_source /repertoire_cible";
    exit 0 # Quitte le shell
elif [ ! -d "$1" -o ! -d "$2" ] # Test que les paramètres soient bien des repertoires
then
    echo il faut renseigner des répertoirs dans les paramètres;
    exit 0
fi
#Paramètres du shell
repertoirSource="${1%/}/" # Supprime le slash de la fin si il existe puis en ajoute un (pour éviter d'en avoir 2 si l'utilisateur l'avait mis)
repertoirCible="${2%/}/"
extension="mkv"
#Fichiers de log pour exploitation future
log="$repertoirCible"log.txt
existant="$repertoirCible"existant.txt
absent="$repertoirCible"absent.txt
erreur="$repertoirCible"erreur.txt

flag="non" #Drapeau pour communiquer entre les fonctions
maintenant=$(date) #Pour afficher l'heure et la date dans le fichier de log

#Fonction pour mettre à jour la date et heure dans la variable.
actualiseTimeOfTreatment() {
    maintenant=$(date '+%Y-%m-%d %H:%M:%S')
}
#Fonction métier besoin de ripper des fichiers mkv en avi avec une selection automatique de la langue francaise si présente
actionMKVtoAVI() {
    fichier="${1##*/}" #Récupération du nom de fichier passé en paramètre (idem que d'utiliser basename)
    echo "${maintenant};${1};demande de conversion." >> "$log";
        # recherche le mapping des pistes audio FR via la commande ffmpeg -i
        # redirection de la sortie 2 vers la 1 car ffmpeg n'affiche pas les informations à l'écran via la sortie standard.
        # recuperation du resultat de grep dans la variable.
    audio=`ffmpeg -i  "$1" 2>&1| grep '(fre): Audi'`
        # supprime de la variable 'Stream #' ainsi que tous ce qui le precede.
    audio="${audio##*Stream #}"
        # supprime de la variable '(fre)' et tous ce qui suit
    audio=${audio%(fre)*}
        # la variable contien à ce moment là soit le mappage attendu pour le francais (ex: '0.1') soit rien
        # même principe pour le mappage de la vidéo car pour mapper en manuel dans ffmpeg il faut lui donner l'ensemble des flux.
        # recherche le mapping de la video via la commande ffmpeg -i
    video=`ffmpeg -i  "$1" 2>&1| grep ': Video'`
    video="${video##*Stream #}"
    video=${video%%(*}
        # si piste audio FR détecté alors force le map dans la conversion.
        # pas de test sur la variable vidéo car en cas d'erreur c'est ffmpeg qui prendra en charge de mapper automatiquement la première piste vidéo.
    if ["${audio}" -e ""]
    then
        echo "${maintenant};${1};Pas de piste audio française trouvée." >> "$log";
        echo "${maintenant};${1};ffmpeg -i $1 -async 1 -s 720x576 -r 24 -ab 128k -b 1200k -aspect 16:9 -ac 2 -v 0 -f avi ${repertoirCible}${fichier%.*}.avi" >> "$log";
        ffmpeg -i "$1" -async 1 -s 720x576 -r 24 -ab 128k -b 1200k -aspect 16:9 -ac 2 -v 0 -f avi "${repertoirCible}${fichier%.*}".avi;
    else
        echo "${maintenant};${1};Piste audio française trouvée." >> "$log";
        echo "${maintenant};${1};ffmpeg -i $1 -async 1 -s 720x576 -r 24 -ab 128k -b 1200k -aspect 16:9 -map ${video} -map ${audio} -ac 2 -v 0 -f avi ${repertoirCible}${fichier%.*}.avi;" >> "$log";
        ffmpeg -i "$1" -async 1 -s 720x576 -r 24 -ab 128k -b 1200k -aspect 16:9 -map "${video}" -map "${audio}" -ac 2 -v 0 -f avi "${repertoirCible}${fichier%.*}".avi;
    fi 
}
actionScript() {
actualiseTimeOfTreatment #demande de mise à jour de la variable temps (maintenant)
if [ "$flag" = "non" ] #Si fichier non trouvé
    then     
        echo "$1" >> "$absent";
        actionMKVtoAVI "$1"
    else    #Si fichier trouvé    
        echo "${maintenant};${1};${flag}" >> "$log" ;
        echo "$1" >> "$existant";
    fi 
    return
}
rechercheCible() { #Dans le cas des boucles for le résultat d'un repertoir n'est pas fini par un '/' c'est pourquoi je l'ajoute apres ${u}"/"
    for u in "$1"* ;do  #Boucle sur tout le contenu du repertoir passé en paramètre
        if [ -d "$u" ] #Si repertoire
        then
            if [ -f "${u}"/"$2" ] #si le fichier existe dans le répertoire 
            then
                flag="${u}"/"$2"  #valorise le flag pour dire que le fichier est présent                    
                return  #quitte la fonction
            else
                rechercheCible "${u}/" "$2" #sinon explore le contenu de ce nouveau répértoire
            fi
        fi
    done
    return #Si je sorts ici alors c'est que je n'ai rien trouvé...
}
rechercheSource() {
    for i in "$1"* ;do #Boucle sur l'ensemble des fichiers 
        flag="non" #Passe le drapeau à non avant de faire la recherche dans le repertoire cible
        if [ -d "$i" ] #Si repetoire
        then 
            rechercheSource "${i}/"  #Recherche dans le sous répertoire
        else
            currentExtension="${i##*.}" #Extraction de l'extension
            nom="${i##*/}"    #extraction du nom de fichier        
            if [ "$currentExtension" = "${extension}" ]
            then    
                if [ -f "${repertoirCible}${nom%.*}".avi ] #si le fichier existe dans le répertoire cible
                then
                    flag="${repertoirCible}${nom%.*}".avi  #valorise le flag pour dire que le fichier est présent
                    actionScript "$i" #Demande l'execution d'une action    
                else
                    rechercheCible "$repertoirCible" "${nom%.*}".avi #recherche sa présence dans les sous répértoires Cible (apres avoir changé son extension)        
                    actionScript "$i" #Demande l'execution d'une action
                fi
            else
                echo "${maintenant};${1};n'est pas un fichier $extension">> "$log";
                echo "$i" >> "$erreur";
            fi
        fi
    done
    return
}

rechercheSource "$repertoirSource" 

echo "Job's done by Tom";

pour suivre en temps réel le traitement du script je fais

tail -f log.txt

Levi59

Petite version pour le script d'imprim-ecran et d'upload sur imgur. Là il se contente d'attendre la sélection de la zone d'écran et l'upload pour mettre un lien pour forum dans le copier collé. Il y a possibilité de régler 2-3 options au début.
(J'ai fait cette petite modif car j'utilise maintenant xfce-screenshooter sous openbox et je ne me sert donc plus de ce script que pour faire des miniatures de forum.)

#!/bin/bash
# script pour créer rapidement et simplement un screenshot d'une zone du bureau
# et de l'envoyer sur imgur. Vous avez le choix de sauvegarder l'image. Vous récupérez
# un lien disponible en collant le contenu du presse papier sous la forme d'un lien ou
# de BBcode contenant le lien et une miniature. Enjoy!
#
# Copyright (C) 22 Jan. 2011, Rombeaut Rodolphe
# http://scriptam.over-blog.com/
# Released into the public domain.

###### Options ######
#Conserver l'image
CONSERVE=0

#Lien pour forum
FORUMLINK=1

# changer en LOG=1 pour conserver la liste des urls des images uploadées
LOG=0

# changer en TAILLE="s" pour le thumbnail small ou en TAILLE="l" (L minuscule) pour le large
TAILLE="s"
###################

# Vérifier dépendances
for i in xsel curl notify-send scrot
do
    [[ ! -x /usr/bin/$i ]] && PAQUETS="${i/notify-send/libnotify-bin} $PAQUETS"
done
[[ -n $PAQUETS ]] && { echo "\
---Erreur : ${0##*/} dépend de $PAQUETS
Utilisez cette commande pour installer les dépendances :
    sudo apt-get install $PAQUETS\
" >&2; exit 1; }

# Emplacement du screenshot pour conservation
[ $CONSERVE -eq 1 ] && {
    LOCATEF=$(zenity --file-selection \
    --title="Dossier d'enregistrement" \
    --filename="${HOME}/" \
    --directory) || {
    notify-send Annulation
    exit 0
    }

# Vérifier la présence d'un fichier screenshot dans le dossier
# Si oui renommer en screenshot(X).jpg ou X est un nombre suffisamment élevé pour
# ne pas écraser l'ancien screenshot
    [ -f "${LOCATEF}/screenshot.jpg" ] && {
        b=1
        while [ -f "${LOCATEF}/screenshot($b).jpg" ] ; do ((b++)) ; done
        SCRSHT="${LOCATEF}/screenshot($b).jpg"
    } || SCRSHT="${LOCATEF}/screenshot.jpg"
} || {

# Si pas d'option, on envoie en dossier /tmp et on supprime tout ancien fichier
# pour ne pas fausser le test suivant
    rm -f /tmp/screenshot.jpg
    SCRSHT="/tmp/screenshot.jpg"
}

notify-send "Selectionnez la zone à uploader avec la souris"
sleep 2

# Cheese! ^^
scrot -s -q 100 -d 1 "${SCRSHT}";
[ -f "${SCRSHT}" ] || {
    notify-send "Pas de screenshot effectué"
    exit 1
}
URL=$(curl -F "image"=@"${SCRSHT}" -F "key"="5d317f0bee23b282473522e1aa68f621" http://imgur.com/api/upload.xml | grep -Eo '<[a-z_]+>http[^<]+' | sed 's/^<.\|_./\U&/g;s/_/ /;s/<\(.*\)>/\1:\ /' | cut -d ' ' -f3 | head -n1)

[ "${LOG}" -eq 1 ] && echo "$(date);${URL}" | tee -a "${HOME}/.${0##*/}.log" ;

# Retour à xsel selon option
[ $FORUMLINK -eq 1 ] && {
    URLSSEXT=${URL%.*}
    echo -n "[url=${URL}][img]http://${TAILLE}.${URLSSEXT#*.}.${URL##*.}[/img][/url]" | xsel -i -b ;
} || {
    echo -n "${URL}" | xsel -i -b ;
}

notify-send "Image Uploadée";
exit 0

Aldian

Salut

Je cherchais à controler de l'extérieur l'exécution de certains programmes. Je me suis souvenu de ce vieux post: Limiter la consommation CPU d'une tache et une fois de plus je me suis demandé "est-ce qu'il est absolument nécessaire de passer par un programme C ultra bourrin?, Ne pourrait-on pas le faire en bash?" et donc j'ai étudié la question, et voici le résultat:

#!/bin/bash
# $1 = name of process
# $2 = percent limit

#init parameters
w=$(echo "scale = 2; $2/100" | bc)
s=$(echo "scale = 2; (100-$2)/100" | bc)
export progname=$1

# run if user hits control-c
control_c()
{
  echo -en "\n*** Ouch! Exiting ***\n"
  pkill $progname
  exit 0
}
 
# trap keyboard interrupt (control-c)
trap control_c SIGINT

#main loop
while true 
do
    echo "STOP proc with name: $1"    
    pkill -SIGSTOP $1
    sleep $s
    echo "CONT proc with name: $1"
    pkill -SIGCONT $1
    sleep $w
done

Je ne suis pas très bon en bash, donc j'ai fait au plus simple, tous vos commentaires sont bienvenus. Je rajouterai dans le sommaire des scripts utiles si je ne me fais pas foudroyer par les gourous du bash 🙂

Le script s'utilise très simplement, il prend en premier argument le nom du programme à limiter et en deuxième argument le pourcentage d'utilisation cpu que l'on souhaite lui attribuer. Les nombres à virgule sont autorisés.

BoingBall

Bonjour,
Je suis un nouvel utilisateur sur linux et souhaite mettre en place un journal cyclique basé sur LibreOffice en récupérant des fichiers odp depuis le serveur vers le local.
Dans un dossier "diffusion", plusieurs fichiers impress sont stockés et portent un numéro incrémental.
Merci d'avance pour votre soutient car j'ai quelques lacunes.

Voici mon ébauche :

#!bin/bash

### suppression du process impress
killall -9 soffice.bin

###suppression des fichiers impress en local
rm -f /home/myspace/diffusion/*.odp

###rafraîchissement de la liste depuis le serveur distant
cp /home/myspace/Diffusion/*.odp /home/myspace/diffusion

cd /home/myspace/diffusion/
i=0
while [ $i -lt ${#odp[0]} ] ; do
          ODP="${odp[$i]}"
          libreoffice -show -nodefault -minimized "$ODP" &
          sleep $pause
          let i++
          if [ $i -eq ${#odp[*]} ] ; then
                         odp=('find /home/myspace/diffusion -name "*.odp"')
                         i=0
          fi
done

exit 0

twocats

libreoffice -show -nodefault -minimized "$ODP" &
sleep $pause

Euh... j'ai du mal a comprendre, d'autant que $pause n'est pas défini.
Le exit 0 à la fin est inutile.

« Page précédente Page suivante »