debdepot: depot local pour Ubuntu avec apt-get

Publié le par JJ

Bonjour !

Voilà un script destiné à ceux qui n'ont pas de connexion internet chez eux. Ce  petit programme permet de mettre à jour , ou d'installer une nouvelle application sur une machine dépourvue de connexion internet.

Il existe des solutions de cache réseau pour les administrateurs qui  ont la chance d'avoir un réseau:  c'est quand même plus pratique pour mettre à jour une multitude de machine.

Il y a des tas de défauts a ce scripts. Cependant ça à l'air de fonctionner correctement, alors...

RESUME
Ce programme télécharge  des paquets sur les dépots Internet (apt repository) depuis une machine A sous debian. Ensuite il n'y a qu'a copier le repertoire cible sur une clef usb par exemple (si ya assez de place) et  copier sur une autre machine B dans un nouveau repertoire. On édite le fichier /etc/apt/sources.list, pour ajouter le repertoire comme source, et on lance la même commande normale d'installation comme si on avait été sur internet. Le depot local que l'on a copié masque le détail qui manque.

MODE D'EMPLOI DETAILLE
(step by step comme on dit)

convention : les lignes de commandes sont présentées en gras italique comme l'exemple suivant:  echo "Hello JerikoJerk"

1 - on se connecte sur la machine A !!!

2 - on colle le script ci dessous dans un fichier texte (gedit...) que l'on nommera par exemple "debdepot.sh"  (le nom est arbitraire)

3
- on rend le script executable chmod +x  debdepot.sh, ou avec l'interface graphique


4
- on installe le paquet dpkg-dev au besoin (droit super-utilisateur nécessaire). apt-get dpkg-dev.On est toujours sur la machine A. Si ce n'est  pas fait le script ne fonctionne pas.

5 - on ammène le terminal dans le repertoire est enregistré le script à l'aide de "cd " et de "ls" pour vérifier.

6 - on crée le dépot dans un répertoire, arbitrairement /home/user_A/depot/  : sh debdepot.sh creer  /home/user_A/depot/

7
- on selectionne les paquets, au choix
  •  * par une entree manuelle: sh debdepot.sh  actualiser /home/user_A/depot/
  •  * par une liste passee en argument: sh debdepot.sh  actualiser  /home/user_A/depot/  ~/liste
  •  * par un tube (attention cette methode donne l'impression d'un bug, avec un affichage qui s'affole mais tout va bien, il peut y avoir 1500 affichages) : dpkg --get-selections | sh debdepot.sh actualiser /home/user_A/depot/
  • le téléchargement débute automatiquement ainsi que la gestion des dépendances. Il y a rarement un conflit à arbitrer, donc vous pouvez prendre une pause pendant que ma cuisine fonctionne.

    8 - on copie le répertoire /home/user_A/depot/ sur un media amovible.

    9 - on se déconnecte de la machine A

    10
    - on se connecte sur la machine B

    11
    - on connecte le média amovible et on transfère le contenu du média amovible vers un répertoire arbitrairement nommé /home/user_B/depot/ (allez savoir pourquoi)

    12
    - dans un terminal on lance sudo -s avoir la console root (be carefull !!!!). Lorsqu'on n'est pas sous ubuntu, su devrai faire l'affaire.

    13 - dans le terminal root on tape gedit /etc/apt/sources.list et on ajoute la ligne à la fin du fichier  :
    deb file: /home/user_B/depot ./  #depot local

    14
    - on sauvegarde et on ferme gedit

    15 - dans le même terminal on lance:
    apt-get update pour prendre en compte le nouveau dépot.

    16
    - ensuite celon ce qu'on veut faire:
    * apt-get  upgrade pour mettre a jour les logiciels,
    * apt-get install gnagna pour installer "gnagna"
    17 - enfin exit pour quitter la console root, (sudo -k  pour faire expirer le bail  de  sudo  )

    A l'étape 16 et 17, il  y a des warnings pour signaler que le dépot n'est pas authentifié. Cet avertissement est normal, je n'ai pas réussi à intégrer une signature qui n'apporte pas grand chose, puisque au moment ou les paquets ont été téléchargés, la signature du site dépot à été vérifiée.

    LE SCRIPT

    #!/bin/sh 
    # Autor : jerikojerk (jerikojerk.over-blog.net)
    # Copyright : some rights reserved

    back="`pwd`"
    repertoire="`dirname $0`"
    cd "$repertoire"
    repertoire="`pwd`"


    ################################################################################

    W_BINAIRE="warnig_packages.log" # you may custom this
    W_SOURCE="warnig_sources.log" # you may custom this

    # this some of this variables are true const.
    LISTS="lists"
    ARCHIVES="archives"
    APT_CONF_D="apt.conf.d"
    BINAIRE="Packages.gz"
    SOURCE="Sources.gz"
    SOURCES_LIST="sources.list"
    APT_CONF="apt.conf"
    PREFERENCES="preferences"
    PAQUETS_DEPOT="paquets.lst"
    STATUS="status"
    DEPOT_CREATE="creer_depot.sh"
    DEPOT_UPDATE="actualiser_depot.sh"
    OVERRIDE="/dev/null"

    #if you want to change color of help to fit your shell.
    C_VERT="33[1;32m" #green
    C_NORMAL="33[0;39m" # defaut
    C_ROUGE="33[1;31m" #red
    C_ROSE="33[1;35m" #pink
    C_BLEU="33[1;34m" #blue
    C_BLANC="33[0;02m" #white
    C_BLANCLAIR="33[1;08m" #white strong
    C_JAUNE="33[1;33m" #yellow
    C_CYAN="33[1;36m" #cyan

    ################################################################################
    function aide(){
    echo "usages:"

    echo -e " `basename $0` $C_ROSE actualiser $C_NORMAL [depot local] [liste de paquets | ]"
    echo -e " met à jour un depot."
    echo -e " `basename $0` $C_ROSE comparer $C_NORMAL [depot local] [liste de paquets]"
    echo -e " verifie si les deux listes sont identiques, retourne 0 si oui"
    echo -e " `basename $0` $C_ROSE creer $C_NORMAL [depot local] "
    echo -e " cree un depot."
    echo -e " `basename $0` $C_ROSE effacer $C_NORMAL [depot local]"
    echo -e " efface le depot."
    echo -e " `basename $0` $C_ROSE enlever $C_NORMAL [depot local]"
    echo -e " enlève le paquet du depot."
    echo -e " `basename $0` $C_ROSE index $C_NORMAL [depot local]"
    echo -e " regenère l'index du depot."
    echo -e " `basename $0` $C_ROSE liste $C_NORMAL [depot local] [liste]"
    echo -e " positionne une liste de reference pour le depot local"
    echo -e " `basename $0` $C_ROSE montrer $C_NORMAL [depot local] [ nom du paquet] "
    echo -e " enlève un paquet sans ses dependances"
    echo -e " `basename $0` $C_ROSE stats $C_NORMAL [depot local]"
    echo -e " some nice stuff"
    echo
    echo " [depot local] signifie le repertoire qui contient le depot local, preferez les repertoires absolus"
    echo
    echo "$0 was design by Jerikojerk, some rights reserved."
    echo -e "Please visit $C_BLEU jerikojerk.over-blog.net $C_NORMAL"
    echo -e "email: $C_BLEU jerikojerk $C_NORMAL*$C_BLEU hotmail $C_NORMAL*$C_BLEU fr $C_NORMAL"
    echo
    }

    ################################################################################
    function analyser(){
    local repertoire;repertoire="$1//";repertoire="${repertoire%%//*}"
    apt-cache -c "$repertoire/$APT_CONF" stats
    }

    ################################################################################
    function actualiser() {
    local cpt
    local i
    local liste
    local mode
    local paire
    local paquet
    local repertoire
    local tmp

    tmp="/tmp/modifier_depot$(date +%s)"
    repertoire="$1//";repertoire="${repertoire%%//*}" # enlever les "/" finaux.
    liste=""
    cpt=0

    # basis directory is $repertoire
    echo "repertoire de base du depot: $repertoire"

    if [ ! -d "$repertoire" ];then
    if ! mkdir -p "$repertoire";then
    # unable to create directory
    echo "impossible de creer le répertoire"
    aide
    exit 1
    fi
    fi

    # accepte le mode interactif ou le mode pas interactif
    if [ -z "$2" ]; then
    mode="i" #script interactif
    elif [ -f "$2" ] ;then
    mode="n" # script non interactif
    else
    #faillure file $2 not found
    echo "erreur: fichier '$2' introuvable"
    aide
    exit 2
    fi

    test -f "$repertoire/$PAQUETS_DEPOT" && mv "$repertoire/$PAQUETS_DEPOT" "$repertoire/$PAQUETS_DEPOT.bak"

    if [ "_$mode" != "_n" ];then
    #read standard input, one *.deb per line please
    echo "Lecture de l'entree standart, un paquet par ligne"
    # stop reading with EOF or #. word
    echo
    while echo -n "fin: '#.' ?" && read ligne
    do
    if [ "_$ligne" == "_#." ];then
    break
    else
    paire="${ligne%%#*}" #on elimine les commentaires
    paire="${paire%% *}" # on filtre tout ce qui est à droite d'une tabulation
    paquet="${paire%% *}" # ici on vire les espaces
    liste="$liste $paquet"
    cpt=$((cpt + 1))
    fi
    done

    else
    # to be factorized
    #read file $2
    echo "Lecture du fichier $2"
    while echo -n "fin: '#.' ?" && read ligne< "$2"
    do
    # useless
    if [ "_$ligne" == "_#." ];then
    break
    else
    paire="${ligne%%#*}" #on elimine les commentaires
    paire="${paire%% *}" # ici on enleve une ligne à partir de sa première tabulation
    paquet="${paire%% *}" # ici on vire les espaces, si jamais les tab on été remplacée par des espaces
    liste="$liste $paquet"
    cpt=$((cpt + 1))
    fi
    done

    #retrier le fichier de sortie
    sort --unique --field-separator=n "$repertoire/$PAQUETS_DEPOT" "$2" 1> "$tmp"
    cat "$tmp" > "$repertoire/$PAQUETS_DEPOT"
    rm "$tmp"
    fi

    # files to download
    echo "paquets a rendre disponible:"
    echo "$liste"
    # total: $cpt files
    echo "total: $cpt fichiers"

    # download

    if [ -n "$liste" ]; then
    # apt-get + fichier de configuration
    echo "mise a jour de la base de donnees"
    apt-get update -c "$repertoire/$APT_CONF" --quiet
    echo
    echo "debut du telechargement"
    echo
    if ! apt-get install -c "$repertoire/$APT_CONF" --quiet --assume-yes $liste ; then
    wait
    echo
    echo "un des paquets n'a pu etre telecharge, essai de telecharger les paquets un par un"
    echo
    for i in $liste
    do
    echo
    echo
    if ! apt-get install -c "$repertoire/$APT_CONF" --quiet --assume-yes $i; then # pas de guillemets pour liste
    wait
    echo "erreur de recuperation du paquet:"
    echo "$i"
    echo "> validez pour tenter de continuer ou Ctrl + C pour annuler"
    read ligne
    fi
    done
    fi
    else
    echo "Pas de paquet en entree"
    aide
    exit 2
    fi

    generer_index "$repertoire"
    return 0
    }

    ################################################################################
    # generer apt.conf
    function creer(){
    local repertoire
    repertoire="$1//";repertoire="${repertoire%%//*}"

    # creating directories
    echo "creation de l'arborescence "
    creer_arborescence "$repertoire"
    wait
    # creating config files
    echo "creation des fichiers de configuration"
    creer_sourceslist "$repertoire"
    creer_aptconf "$repertoire"
    creer_preferences "$repertoire"
    creer_status "$repertoire"

    wait
    echo "Fin de configuration du depot, vous pouvez maintenant ajouter des paquets."
    echo "Pour ajouter des paquets faites:"
    echo "sh `basename $0` actualiser $repertoire [ liste de paquet | ]"

    }

    ################################################################################
    # generer apt.conf
    function creer_aptconf(){ # repertoire #arch #cible
    local repertoire
    local fichier_cible
    local achitecture

    repertoire="$1//";repertoire="${repertoire%%//*}"

    if [ -z "$2" ]; then
    achitecture="i386"
    else
    # other archtecture selected
    achitecture="$2";echo "architecture definie par l'utilisateur:$achitecture"
    fi

    fichier_cible="$repertoire/$APT_CONF"

    echo "// apt.conf" > $fichier_cible
    echo "APT" >> $fichier_cible
    echo "{" >> $fichier_cible
    echo " Architecture "$achitecture";" >> $fichier_cible
    echo " Get::Download-Only "true";" >> $fichier_cible
    echo " Get::Upgrade "true";" >> $fichier_cible
    echo " Clean-Installed "false";" >> $fichier_cible
    echo " Cache-Limit "134217728";" >> $fichier_cible # pretty cache
    echo " Assume-Yes "true";" >> $fichier_cible
    echo " Fix-Broken "true";" >> $fichier_cible
    # echo " Recommends-Important "true";" >> $fichier_cible
    echo "};" >> $fichier_cible
    echo "" >> $fichier_cible
    echo "Dir" >> $fichier_cible
    echo "{" >> $fichier_cible
    echo " State "$repertoire/";" >> $fichier_cible
    echo " State::status "$STATUS";" >> $fichier_cible
    echo " State::Lists "$LISTS";" >> $fichier_cible
    echo " Cache "/$repertoire/";" >> $fichier_cible
    echo " Cache::archives "$ARCHIVES/";" >> $fichier_cible
    echo " Etc "$repertoire/";" >> $fichier_cible
    echo " Etc::SourceList "$SOURCES_LIST";" >> $fichier_cible
    echo " Etc::Main "$APT_CONF";" >> $fichier_cible
    echo " Etc::Preferences "$PREFERENCES";" >> $fichier_cible
    echo " Etc::Parts "$APT_CONF_D/";" >> $fichier_cible
    echo "};" >> $fichier_cible
    echo "Acquire::Retries "3";" >> $fichier_cible

    return 0
    }

    ################################################################################
    # apt
    # sur que c'est peu pratique si on ajouter un depot par defaut.
    # pour ajouter un depot il faut inserer une ligne du style
    # echo "ligne du depot" >> $fichier_cible
    # sinon on peut appeler le script avec l'action creer, puis éditer le sources.list à la mains

    function creer_sourceslist(){ #repertoire #distribution name #cible
    local repertoire
    local distribution
    local fichier_cible

    repertoire="$1//";repertoire="${repertoire%%//*}"

    if [ -z "$2" ]; then
    distribution="dapper"
    else
    distribution="$2";echo "distribution definie par l'utilisateur:$distribution"
    fi

    fichier_cible="$repertoire/$SOURCES_LIST"

    # eventuellement tester si le depot est actif avant de l'inscrire dans le fichier.
    adresse="fr.archive.ubuntu.com"
    tester_serveur "$adresse"

    echo "####### SOURCES.LIST DEPOT LOCAL $distribution#######" > $fichier_cible
    echo -e "n## 'main'" >> $fichier_cible
    echo "deb http://$adresse/ubuntu/ $distribution main" >> $fichier_cible
    echo "deb-src http://$adresse/ubuntu/ $distribution main" >> $fichier_cible

    echo -e "n## 'restricted'" >> $fichier_cible
    echo "deb http://$adresse/ubuntu/ $distribution restricted" >> $fichier_cible
    echo "deb-src http://$adresse/ubuntu/ $distribution restricted" >> $fichier_cible

    echo -e "n## 'universe' repository." >> $fichier_cible
    echo "deb http://$adresse/ubuntu/ $distribution universe" >> $fichier_cible
    echo "deb-src http://$adresse/ubuntu/ $distribution universe" >> $fichier_cible

    echo -e "n## 'multiverse'" >> $fichier_cible
    echo "deb http://$adresse/ubuntu/ $distribution multiverse" >> $fichier_cible
    echo "deb-src http://$adresse/ubuntu/ $distribution multiverse" >> $fichier_cible

    echo -e "n## 'bug fix'" >> $fichier_cible
    echo "deb http://$adresse/ubuntu/ $distribution-updates main restricted" >> $fichier_cible
    echo "deb-src http://$adresse/ubuntu/ $distribution-updates main restricted" >> $fichier_cible

    echo -e "n## 'backports'" >> $fichier_cible
    echo "deb http://$adresse/ubuntu/ $distribution-backports main restricted" >> $fichier_cible
    echo "deb-src http://$adresse/ubuntu/ $distribution-backports main restricted" >> $fichier_cible
    echo "deb http://$adresse/ubuntu/ $distribution-backports universe multiverse" >> $fichier_cible
    echo "deb-src http://$adresse/ubuntu/ $distribution-backports universe multiverse" >> $fichier_cible

    adresse="security.ubuntu.com"
    tester_serveur "$adresse"
    echo -e "n## ''securite'" >> $fichier_cible
    echo "deb http://$adresse/ubuntu $distribution-security main restricted" >> $fichier_cible
    echo "deb-src http://$adresse/ubuntu $distribution-security main restricted" >> $fichier_cible

    echo "deb http://$adresse/ubuntu $distribution-security universe multiverse" >> $fichier_cible
    echo "deb-src http://$adresse/ubuntu $distribution-security universe multiverse">> $fichier_cible
    return 0
    }

    ################################################################################
    function creer_preferences(){
    # on ne souhaite pas améliorer ça
    local repertoire
    local fichier_cible

    repertoire="$1//";repertoire="${repertoire%%//*}"
    fichier_cible="$repertoire/$PREFERENCES"
    touch "$fichier_cible"
    rm "$fichier_cible"
    touch "$fichier_cible"

    return 0
    }

    ################################################################################
    function creer_status(){
    local repertoire
    local fichier_cible
    # on ne souhaite pas améliorer ça

    repertoire="$1//";repertoire="${repertoire%%//*}"
    fichier_cible="$repertoire/$STATUS"
    touch "$fichier_cible"
    rm "$fichier_cible"
    touch "$fichier_cible"

    return 0
    }

    #################################################################################
    function creer_arborescence(){
    local repertoire

    repertoire="$1//";repertoire="${repertoire%%//*}"
    if [ ! -d "$repertoire" ]; then
    mkdir -p "$repertoire"
    else
    if [ ! -r "$repertoire" ]; then
    if ! chmod +r "$repertoire"; then
    echo "Vous ne pouvez pas lire le repertoire"
    fi
    fi
    if [ ! -w "$repertoire" ]; then
    if ! chmod +w "$repertoire"; then
    echo "Vous ne pouvez pas modifier le repertoire"
    fi
    fi
    if [ ! -x "$repertoire" ]; then
    if ! chmod +x "$repertoire"; then
    echo "Vous ne pouvez pas executer dans le repertoire"
    fi
    fi
    fi


    if [ ! -d "$repertoire/$ARCHIVES/partial" ] ; then
    mkdir -p "$repertoire/$ARCHIVES/partial"
    fi

    if [ ! -d "$repertoire/$LISTS/partial" ]; then
    mkdir -p "$repertoire/$LISTS/partial"
    fi

    touch "$repertoire/$BINAIRE"
    #ln -sv "$repertoire/$ARCHIVES/$BINAIRE" "$repertoire/$BINAIRE"

    return 0
    }

    ################################################################################
    function effacer(){

    local repertoire;

    if [ -d "$1" ];then
    repertoire="$1//";repertoire="${repertoire%%//*}"
    else
    echo "repertoire introuvable"
    exit 1
    fi

    analyser "$repertoire"
    echo " ********************************************************* "
    echo " Confimer l'effacement complet du repertoire? [ oui / non] "
    read reponse
    if [ "_$reponse" == "_oui" ];then
    rm -vR "$repertoire"
    elif [ "_$reponse" == "_non" ];then
    echo "annule !"
    else
    echo "il faut repondre oui ou non."
    fi
    return 0
    }

    ################################################################################
    function enlever(){
    local repertoire
    local paquet
    local ligne
    repertoire="$1//";repertoire="${repertoire%%//*}"
    cd "$repertoire/$ARCHIVES"
    # positif answer is yes

    echo "N'enleve pas les dependances... pour confirmer: 'y' 'yes' 'o' 'oui'"
    echo
    while echo -n "fin: '#.' ?" && read ligne
    do
    if [ "_$ligne" == "_#." ];then
    break
    else
    if basename "$ligne"*; then
    paquet=`basename $ligne*`
    paquet="$repertoire/$ARCHIVES/$paquet"
    rm -i "$paquet"
    else
    echo "non trouvé, ou trop de possibilité"
    ls "$ligne"*
    fi
    fi
    done
    echo "reconstruction de l'index"
    generer_index "$repertoire"
    return 0
    }

    ################################################################################
    # regenere le fichier Packages.gz ($BINAIRE) en fonction des fichiers deb présent dans le répertoire passé en paramettre
    function generer_index(){

    local repertoire
    repertoire="$1//";repertoire="${repertoire%%//*}"

    tester_install || exit 127 # necessaire parce qu'on redirige le flux d'erreur pour virer le warning

    if cd "$repertoire"; then
    echo "attendez pendant la generation de l'index..."
    if [ -e "$repertoire/$BINAIRE" ];then
    rm "$repertoire/$BINAIRE"
    fi
    dpkg-scanpackages "$ARCHIVES" "$OVERRIDE" 2> "$W_BINAIRE" | gzip -9c > "$BINAIRE"
    #ln -sv "$repertoire/$ARCHIVES/$BINAIRE" "$repertoire/$BINAIRE"

    echo -n "..."
    #dpkg-scansources "$ARCHIVES" "$OVERRIDE" 2> "$W_SOURCE" | gzip -9c > "$SOURCE"
    echo "ok!"

    #echo "inserez les lignes suivantes a votre fichier /etc/apt/sources.list:"
    #add the following line to your sources.list
    echo "inserez la ligne suivante a votre fichier /etc/apt/sources.list:"
    echo "deb file:$repertoire ./"
    #echo "deb-src file:$repertoire/ ./"
    return 0
    else
    echo "erreur: Arg 1"
    exit 1
    fi
    }

    ################################################################################
    function lister(){
    local repertoire;

    if [ -d "$1" ];then
    repertoire="$1//";repertoire="${repertoire%%//*}"
    else
    echo "repertoire introuvable"
    exit 1
    fi

    if [ -f "$2" ];then
    echo -e "Fichier selectionne:n"
    cat "$2"
    if [ $? -eq 0 ]; then
    echo -e "nncopie simple du fichier"
    cp -v "$2" "$repertoire/$PAQUETS_DEPOT"
    echo "n'oubliez pas d'actualiser le depot maintenant"
    echo "votre depot contiendra au moins les paquets de la nouvelle liste"
    else
    echo "fichier source non lisible"
    aide
    exit 2
    fi
    else
    echo "la liste n'existe pas"
    aide
    exit 2
    fi
    return 0
    }

    ################################################################################
    function verifier(){

    local repertoire;

    if [ -d "$1" ];then
    repertoire="$1//";repertoire="${repertoire%%//*}"
    else
    echo "repertoire introuvable"
    exit 1
    fi

    if [ -f "$repertoire/$PAQUETS_DEPOT" ];then
    echo "test de similitude des fichiers de listes de paquets"
    if diff --suppress-common-lines "$repertoire/$PAQUETS_DEPOT" "$2"; then
    echo "les listes de paquets concordent."
    return 0
    else
    echo "les listes de paquets sont differentes"
    echo "Veuillez à mettre à jour votre depot et votre kit de securite".
    fi
    else
    echo "il n'y a pas de listes de paquets preenregistree dans le depot."
    echo "pour activer faites:"
    echo "`basename $0` liste [depot local] [nom de la liste]"
    fi
    return 1
    }

    ################################################################################
    function montrer(){

    local repertoire;repertoire="$1//";repertoire="${repertoire%%//*}"
    apt-cache -c "$repertoire/$APT_CONF" show "$2"
    return 0
    }

    ################################################################################
    function tester_install(){
    dpkg-scanpackages &> /dev/null
    if [ $? -eq 127 ];then
    echo
    echo "le paquet dpkg-dev (dpkg-scanpackages) semble ne pas etre installe sur ce systeme"
    echo "vous devez fixer ce probleme imperativement"
    echo
    echo "apt-get install dpkg-dev "
    echo
    return 127
    fi

    gzip --version &> /dev/null #celui ci ne devrai pas poser de problèmes.
    if [ $? -eq 127 ];then
    echo
    echo "le paquet gzip semble ne pas etre installe sur ce systeme"
    echo "vous devez fixer ce probleme imperativement"
    echo
    echo "apt-get install gzip "
    echo
    return 127
    fi

    apt-cache &> /dev/null #celui ci ne devrai pas poser de problèmes.
    if [ $? -eq 127 ];then
    echo
    echo "le paquet gzip semble ne pas etre installe sur ce systeme"
    echo "vous devez fixer ce probleme imperativement"
    echo
    echo "apt-get install apt-cache "
    echo
    return 127
    fi

    return 0
    }
    ################################################################################
    # test si un serveur est fonctionnel. ce test est indicatif, parfois les serveurs bloquent les ping
    function tester_serveur(){
    if ping -Aq -c 3 "$1" &> /dev/null ; then
    #marche mieux avec un résultat positif qu avec un résultat non négatif
    return 0
    else
    echo "Le serveur '$1' ne repond pas"
    return 1
    fi
    }

    ################################################################################
    ################################################################################


    case "$1" in
    "remove" | "enlever")
    tester_install || exit 1
    if [ -z "$4" ];then
    enlever "$2" "$3"
    else
    aide;exit 2
    fi
    ;;

    "erase" | "effacer")
    if [ -z "$3" ];then
    effacer "$2"
    else
    aide;exit 2
    fi
    ;;

    "lister"|"list")
    if [ -z "$4" ];then
    lister "$2" "$3"
    else
    aide;exit 2
    fi
    ;;

    "show" | "montrer")
    if [ -z "$4" ];then
    montrer "$2" "$3"
    else
    aide;exit 2
    fi
    ;;

    "stats")
    if [ -z "$3" ];then
    analyser "$2"
    else
    aide;exit 2
    fi
    ;;

    "comparer" | "comparer")
    if [ -z "$4" ];then
    verifier "$2" "$3"
    else
    aide;exit 2
    fi
    ;;

    "index")
    if [ -z "$3" ];then
    generer_index "$2"
    else
    aide;exit 2
    fi
    ;;

    "update" | "actualiser")
    tester_install || exit 1
    if [ -z "$3" ];then
    actualiser "$2"
    else
    aide;exit 2
    fi
    ;;

    "create" | "creer")
    if [ -z "$3" ];then
    creer "$2"
    else
    aide;exit 2
    fi
    ;;

    *)# defaut
    aide;exit 1
    ;;
    esac


    exit 0



    Publié dans Ubuntu

    Commenter cet article

    CneGroumF 15/12/2006 14:51

    Euh... debmirror ne te convenait pas ?

    jj 29/11/2006 01:52

    pas tout a fait. En fait ça sert à télécharger sur un ordinateur les fichiers nécessaires pour installer des programmes (les paquets) qui n'est pas l'ordinateur sur lequel tu vas installer le programme.LA ou mon truc est génial c'est que tu devrais te connecter uniquement sur un dépot VALABLE pour ta distribution donc tu es sur que le paquet que tu récuperes est compatible avec ta distribution.tu récuperes ensuite tout ce que tu veux... Avec les dépendances de tout ce que tu veux. ( les dépendances c'est un peux comme si tu installes un logiciel pour lire des mp3 (WMédiaPlayer, WinAmp, ...,) alors il faudrait que tu installes un logiciel pour décoder le mp3 (le codec), ce codec serait une dépendance dans débian)Ben ouai, les versions "debian" et "Ubuntu" des paquets c'est pas toujours les mêmes. donc...

    lauryle 06/09/2006 10:25

    c'est génial, je n'y comprend toujours rien...
    la, c'est un truc pour deplacer des programme en faisant croire que ça en n'est pas ?