# [PORTAGE] Gentoo sans Internet (offline-emerge)

## Magic Banana

Ciao!

Cela fait une dizaine de mois que je suis sans connexion Internet... et pourtant ma Gentoo es à jour ! Mon secret réside en trois petits scripts. Un qui stocke sur un support amovible les fichiers à "fetcher" (que ce soit pour une mise à jour ou une nouvelle installation) : remote-emerge. Un autre qui permet depuis une autre machine (type *NIX mais pas nécessairement Gentoo) de télécharger ces fichiers : remote-fetch. Enfin le troisième script m'installe tout ce que j'ai demandé : homesweethome (si vous avez un meilleur nom...  :Very Happy:  ).

Ceci est le comportement de base. Toutefois, ayant un peu d'ambition et bien qu'étant newbie du bash, j'ai voulu ajouter quelques contraintes :

1) remote-emerge peut faire tout ce que fait emerge avec la même syntaxe. Dans le cas où une connexion Internet n'est pas nécessaire à la tâche, remote-emerge l'exécute directement à l'aide d'emerge. Dans l'idéal, l'utilisateur qui serait offline pourrait faire en sorte que emerge soit un alias vers remote-emerge et que les deux autres scripts soit automatiquement lancé au montage du support amovible.

2) Aucune nécessité pour l'utilisateur de se souvenir de ce qu'il a demandé. Autrement dit, lors de l'utilisation de homesweethome, il n'y a qu'à lancer ce script sans aucun argument.

3) Possibilité entre l'utilisation du premier et du troisième script de renoncer facilement à ce que l'on voulait faire. Ainsi si je demande l'installation de kde et finalement change d'avis, je n'ai qu'à supprimer un fichier "kde" sur mon support amovible.

4) Gestion de l'arbre Portage automatique. La commande "emerge --sync" n'est plus nécessaire.

5) Si le périphérique amovible ne peut contenir toutes les sources nécessaire à l'exécutation d'une tâche (d'installation ou de mise à jour), alors le téléchargement des sources se fait en plusieurs aller-retours entre la Gentoo sans Internet et l'autre machine sur Internet. L'installation se fera une fois l'ensemble des sources disponibles.

Pour l'instant ces scripts ne sont pas tout à fait fonctionnels à cause de mes lacunes en bash et de mon impossibilité à les tester facilement (il faudrait pour cela que j'ai un accès Internet chez moi !). Voilà les trois scripts avec en commentaire les choses qui ne fonctionnent pas (BUG) et les choses à faire (TODO).

NB : Les variable PORTDIR, DISTDIR et MOVINGDIR sont à modifier suivant votre installation Gentoo et le répertoire de votre support amovible. Dans mon cas PORTDIR est /usr/portage (installation classique), DISTDIR est /usr/portage/distfiles (installation classique) et MOVINGDIR est /mnt/usb-storage/gentoo/remote-emerge lorsque je suis sur ma Gentoo (script 1 et 3) et /media/usbdisk/gentoo/remote-emerge lorsque je suis sur la machine connectée à Internet (script 2).

```
#!/bin/bash

# Distributed under the terms of the GNU General Public License v2

DISTDIR='/usr/portage/distfiles'

MOVINGDIR='/mnt/usb-storage/gentoo/remote-emerge'

# For any operation which does not require any fetch, use directly emerge

for arg in $*

  do

  case $arg in

      --clean      ) /usr/bin/emerge $* && exit;;

      --depclean   ) /usr/bin/emerge $* && exit;;

      --help       ) echo "remote-emerge uses exactly the same syntax as emerge:" && /usr/bin/emerge $* && exit;;

      --info       ) /usr/bin/emerge $* && exit;;

      --metadata   ) /usr/bin/emerge $* && exit;;

      --pretend    ) /usr/bin/emerge $* && exit;;

      --prune      ) /usr/bin/emerge $* && exit;;

      --regen      ) /usr/bin/emerge $* && exit;;

      --search     ) /usr/bin/emerge $* && exit;;

      --searchdesc ) /usr/bin/emerge $* && exit;;

      --version    ) /usr/bin/emerge $* && exit;;

      -*c*         ) /usr/bin/emerge $* && exit;;

      -*h*         ) echo "remote-emerge uses exactly the same syntax as emerge:" && /usr/bin/emerge $* && exit;;

      -*p*         ) /usr/bin/emerge $* && exit;;

      -*P*         ) /usr/bin/emerge $* && exit;;

      -*s*         ) /usr/bin/emerge $* && exit;;

      -*S*         ) /usr/bin/emerge $* && exit;;

      -*V*         ) /usr/bin/emerge $* && exit;;

  esac

done

# Store a newline in a shell variable (needed by the cut command)

newline='

'

/usr/bin/emerge -fp $* 1> /dev/null 2> ~/.tempfile1

# Strip out fetch-restrict messages, turn spaces into newlines and remove blank lines

cat ~/.tempfile1 | grep -v '^!!!' | cut -d " " -f 1- --output-delim="$newline" | grep -v '^$' | awk -F / '{print $NF" "$0}'z > ~/.tempfile2

rm ~/.tempfile1

# Strip out fetch-restrict messages, turn spaces into newlines and remove blank lines (I found that on a forum and do not really get it)

last=""

while read file url

  do

  if [ "$file" = "$last" ]

      then

      echo $url >> "$MOVINGDIR/urls/$*"

  elif [ ! -f "$DISTDIR/$file" ]

      then

      echo $url >> "$MOVINGDIR/urls/$*"

      last="$file"

  fi

done < ~/.tempfile2

rm ~/.tempfile2

# If DISTDIR already contains everything needed then install

if [ ! -f "$MOVINGDIR/urls/$*" ]

    then

    /usr/bin/emerge $*

fi

```

```
#!/bin/bash

# Distributed under the terms of the GNU General Public License v2

MOVINGDIR='/media/usbdisk/gentoo/remote-emerge'

# Let's fetch!

for URLlist in "$MOVINGDIR/urls/*"

  do

  wget -nc -nd -P $MOVINGDIR/distfiles -i $URLlist

done

# Every list of URLs is cleaned: the sources which are eventualy fetched lead to the suppression of the related lines

for URLlist in "$MOVINGDIR/urls/*"

  do

  for source in "$MOVINGDIR/distfiles/*"

    do

# BUG: The next line should not work properly since $source contains the full name of the file. I want the part of it after the last '/'. However it seems to work a little bit! (why???)

    sed "/$source/d" $URLlist > $MOVINGDIR/.tempfile

    mv $MOVINGDIR/.tempfile $URLlist

  done

done

# Let's fetch the portage tree

# TODO: Store the date of the last tree that has been fetched to fetch the tree no more than once a day

# TODO: Use the variable GENTOO_MIRRORS and the list of all portage mirrors (in /usr/portage/profile/thirdpartymirrors?)

wget -nc -nd -P $MOVINGDIR http://www.die.unipd.it/pub/Linux/distributions/gentoo-sources/snapshots/portage-latest.tar.bz2

```

```
#!/bin/bash

# Distributed under the terms of the GNU General Public License v2

PORTDIR='/usr/portage'

DISTDIR='/usr/portage/distfiles'

MOVINGDIR='/mnt/usb-storage/gentoo/remote-emerge'

mv $MOVINGDIR/distfiles/* $DISTDIR

# Since most of the amovible media uses VFAT which does not implement permissions and that I love clean permissions :

chmod 644 $DISTDIR/*

for software in $MOVINGDIR/*

  do

  if [ ! -s $software ]

      then

# This is not the distfiles directory

# BUG: The next line simply does not work since $software contains the full name of the file. I want the part of it after the last '/'

      emerge $software

      rm $software

  fi

done

if ( test -f $MOVINGDIR/portage-latest.tar.bz2 )

    then

# There is a new Portage tree to install

# I remove the old one (but keep the precious disfiles!)

# TODO: Use rsync to gain in performance?

    for dir in $PORTDIR/*

      do

      if [ $dir != $DISTDIR ]

     then

     rm -r $dir

      fi

    done

    tar -xvjf $MOVINGDIR/portage-latest.tar.bz2 -C /usr

    emerge --metadata

    rm $MOVINGDIR/portage-latest.tar.bz2

fi

```

Comme vous pouvez le voir, le problème du moment est comment obtenir la partie d'une variable qui va du dernier '/' à la fin de la variable, autrement dit comment extraire le nom du fichier sans toute l'arborescence. Le pire c'est que je suis certain d'avoir déjà vu une commande (probablement dans core-utils) qui ne sert qu'à cela.

Le reste du travail à faire concerne la synchronisation de l'arbre. Pour l'instant remote-fetch télécharge toujours le snapshot à moins qu'un snapshot téléchargé précédemment soit encore sur le périphérique amovible (et donc pas encore installé). Cela ne me satisfait vraiment pas puisque :

1) Peut-être que le snapshot disponible online est plus récent que celui sur le périphérique amovible (si le périphérique amovible ne touche pas ma Gentoo pendant plus de 24 heures).

2) Peut-être que le snapshot a déjà été téléchargé et décompressé dans la journée. Le retélécharger et le redécompresser est une perte de bande passante et de temps CPU.

Bref, il faudrait écrire (dans un fichier caché sur la clé ?) une date du dernier téléchargement de l'arbre et l'utiliser. Ces deux étapes doivent être effectuées dans remote-fetch.

De plus le mirroir que j'utilise pour télécharger le snapshot est inscrit en dur dans le code. À la place, remote-fetch devrait utiliser la variable GENTOO_PORTAGE et, je crois, $PORTDIR/profile/thirdpartymirrors. Ceci devrait être effectué dans remote-emerge.

En outre je suppose qu'utiliser rsync doit me permettre un gain de performance non négligeable sur la mise à jour de l'arbre. Mais je n'ai jamais utilisé cette commande...  :Embarassed: 

Enfin, comme vous pouvez le constater, ces scripts nécessitent une certaine structure de fichier sur le périphérique amovible (les répertoires urls et distfiles avec le même père). Ce serait bien de vérifier que cette structure est bien présente et de la créer dans le cas contraire.

Voilà. J'espère qu'une âme généreuse va bien vouloir m'aider à finir tout cela... Je rentre chez moi et ne pourrai donc pas vous lire avant demain matin.  :Crying or Very sad: Last edited by Magic Banana on Fri Dec 01, 2006 9:52 am; edited 3 times in total

----------

## truc

 *Quote:*   

> Comme vous pouvez le voir, le problème du moment est comment obtenir la partie d'une variable qui va du dernier '/' à la fin de la variable, autrement dit comment extraire le nom du fichier sans toute l'arborescence. Le pire c'est que je suis certain d'avoir déjà vu une commande (probablement dans core-utils) qui ne sert qu'à cela. 

 

j'ai pas tout lu mais ça je peux répondre  :Wink: 

```
echo $TRUC

/usr/bin/truc

echo ${TRUC##*/}

truc

# de même

echo ${TRUC%/*}

/usr/bin
```

voili-voilou

Sinon, certains te diront surement que tu peux utiliser dirname, et basename, mais bon.. :Smile: 

EDIT: ah oui et le "$PORTDIR/profile/thirdpartymirrors" si tu regardes un peu dedans (je ne sais pas si c'est évident remarque.. ) c'est enfait pour permettre de mettre SRI_URI=mirror://gentoo ou sourceforge à la place de gentoo etc.. ainsi, à l'exécution ça pourra essayer les différents serveur de ce "nom/type" jusqu'a ce que le fichier télécharge

----------

## Magic Banana

Hier soir, en cherchant un peu dans une documentation sur le bash, j'ai aussi trouvé ta solution préférée et l'ai mise dans mes scripts. Il y avait aussi un oublie bête d'un "/urls/" dû au fait que ma précédente version était moins bien organisée (pas de structure particulière).

Je vous redonne les trois scripts corrigés :

```
#!/bin/bash

# Distributed under the terms of the GNU General Public License v2

DISTDIR='/usr/portage/distfiles'

MOVINGDIR='/mnt/usb-storage/gentoo/remote-emerge'

# For any operation which does not require any fetch, use directly emerge

for arg in $*

  do

  case $arg in

      --clean      ) /usr/bin/emerge $* && exit;;

      --depclean   ) /usr/bin/emerge $* && exit;;

      --help       ) echo "remote-emerge uses exactly the same syntax as emerge:" && /usr/bin/emerge $* && exit;;

      --info       ) /usr/bin/emerge $* && exit;;

      --metadata   ) /usr/bin/emerge $* && exit;;

      --pretend    ) /usr/bin/emerge $* && exit;;

      --prune      ) /usr/bin/emerge $* && exit;;

      --regen      ) /usr/bin/emerge $* && exit;;

      --search     ) /usr/bin/emerge $* && exit;;

      --searchdesc ) /usr/bin/emerge $* && exit;;

      --version    ) /usr/bin/emerge $* && exit;;

      -*c*         ) /usr/bin/emerge $* && exit;;

      -*h*         ) echo "remote-emerge uses exactly the same syntax as emerge:" && /usr/bin/emerge $* && exit;;

      -*p*         ) /usr/bin/emerge $* && exit;;

      -*P*         ) /usr/bin/emerge $* && exit;;

      -*s*         ) /usr/bin/emerge $* && exit;;

      -*S*         ) /usr/bin/emerge $* && exit;;

      -*V*         ) /usr/bin/emerge $* && exit;;

  esac

done

# Store a newline in a shell variable (needed by the cut command)

newline='

'

/usr/bin/emerge -fp $* 1> /dev/null 2> ~/.tempfile1

# Strip out fetch-restrict messages, turn spaces into newlines and remove blank lines (I found that on a forum and do not really get it)

cat ~/.tempfile1 | grep -v '^!!!' | cut -d " " -f 1- --output-delim="$newline" | grep -v '^$' | awk -F / '{print $NF" "$0}'z > ~/.tempfile2

rm ~/.tempfile1

# Skip files already in your DISTFILES directory and write the URLs on the amovible device

last=""

while read file url

  do

  if [ "$file" = "$last" ]

      then

      echo $url >> "$MOVINGDIR/urls/$*"

  elif [ ! -f "$DISTDIR/$file" ]

      then

      echo $url >> "$MOVINGDIR/urls/$*"

      last="$file"

  fi

done < ~/.tempfile2

rm ~/.tempfile2

# If DISTDIR already contains everything needed then install

if [ ! -f "$MOVINGDIR/urls/$*" ]

    then

    /usr/bin/emerge $*

fi
```

```
#!/bin/bash

# Distributed under the terms of the GNU General Public License v2

MOVINGDIR='/media/usbdisk/gentoo/remote-emerge'

GENTOO_MIRRORS='http://www.die.unipd.it/pub/Linux/distributions/gentoo-sources'

# Let's fetch!

for URLlist in "$MOVINGDIR/urls/*"

  do

  wget -nc -nd -P $MOVINGDIR/distfiles -i $URLlist

done

# Every list of URLs is cleaned: the sources which are eventualy fetched lead to the suppression of the related lines

for URLlist in "$MOVINGDIR/urls/*"

  do

  for source in "$MOVINGDIR/distfiles/*"

    do

    sed "/${source##*/}/d" $URLlist > $MOVINGDIR/.tempfile

    mv $MOVINGDIR/.tempfile $URLlist

  done

done

# Let's fetch the portage tree

# TODO: Store the date of the last tree that has been fetched to fetch the tree no more than once a day

for mirror in "$GENTOO_MIRRORS"

  do

  wget -nc -nd -P $MOVINGDIR $mirror/snapshots/portage-latest.tar.bz2

done

```

```
#!/bin/bash

# Distributed under the terms of the GNU General Public License v2

PORTDIR='/usr/portage'

DISTDIR='/usr/portage/distfiles'

MOVINGDIR='/mnt/usb-storage/gentoo/remote-emerge'

mv $MOVINGDIR/distfiles/* $DISTDIR

# Since most of the amovible media uses VFAT which does not implement permissions and that I love clean permissions :

chmod 644 $DISTDIR/*

for software in $MOVINGDIR/urls/*

  do

  if [ ! -s $software ]

      then

# This is not the distfiles directory

      emerge ${software##*/}

      rm $software

  fi

done

if ( test -f $MOVINGDIR/portage-latest.tar.bz2 )

    then

# There is a new Portage tree to install

# I remove the old one (but keep the precious disfiles!)

# TODO: Use rsync to gain in performance?

    for dir in $PORTDIR/*

      do

      if [ $dir != $DISTDIR ]

     then

     rm -r $dir

      fi

    done

    tar -xvjf $MOVINGDIR/portage-latest.tar.bz2 -C /usr

    emerge --metadata

    rm $MOVINGDIR/portage-latest.tar.bz2

fi

```

En apparence, il n'y a plus de bug. Mais bon... je n'ai pas encore pu tester tout cela ! Si vous avez une Gentoo online, vous m'intéressez ! Bien sûr ce script ne vous est pas destiné, néanmoins vous pouvez sans bouger faire des tests et avez donc un avantage certain sur moi. Il vaut faudra impérativement changer les valeurs des variable PORTDIR, DISTDIR et MOVINGDIR comme je l'ai expliqué dans le premier post de ce thread. Accesoirement vous pouvez aussi changer GENTOO_MIRRORS qui est utilisée pour indiquer par ordre de préférences les mirroirs Gentoo où télécharger le dernier snapshot de l'arbre Portage. Je vous rappelle également que remote-emerge s'utilise exactement comme emerge et que les deux autre scripts s'utilisent sans argument.

Sinon je relance un appel à idées en ce qui concerne les TODO détaillés à la fin de mon précédent post...

J'ai aussi une nouvelle question. J'ai découvert la commande tempfile qui, en gros, permet de créer un fichier temporaire dans à un endroit qui va bien (typiquement /tmp) et sans se soucier d'un problème de redondance de nom. Quelqu'un a déjà utiliser cela. Comment ?

EDIT : N'oubliez pas non plus de créer les deux répertoires urls et distfiles dans $MOVINGDIR !

EDIT2 : Variable GENTOO_MIRRORS pour configurer le ou les mirroirs Gentoo où télécharger le dernier snapshot de l'arbre Portage

----------

## Magic Banana

Bon... Après test personnel, il manquait quelques guillemets et cela posait problème lorsque remote-emerge est utilisé avec des options comme dans le célèbre (comment ça "pas encore" ?) :

```
# remote-emerge -uDN world
```

Je vous redonne les trois scripts et vous invite à relire la fin de ma précédente contribution pour m'aider à les tester.

```
#!/bin/bash

# Distributed under the terms of the GNU General Public License v2

DISTDIR='/usr/portage/distfiles'

MOVINGDIR='/mnt/usb-storage/gentoo/remote-emerge'

# For any operation which does not require any fetch, use directly emerge

for arg in $*

  do

  case $arg in

      --clean      ) /usr/bin/emerge $* && exit;;

      --depclean   ) /usr/bin/emerge $* && exit;;

      --help       ) echo "remote-emerge uses exactly the same syntax as emerge:" && /usr/bin/emerge $* && exit;;

      --info       ) /usr/bin/emerge $* && exit;;

      --metadata   ) /usr/bin/emerge $* && exit;;

      --pretend    ) /usr/bin/emerge $* && exit;;

      --prune      ) /usr/bin/emerge $* && exit;;

      --regen      ) /usr/bin/emerge $* && exit;;

      --search     ) /usr/bin/emerge $* && exit;;

      --searchdesc ) /usr/bin/emerge $* && exit;;

      --version    ) /usr/bin/emerge $* && exit;;

      -*c*         ) /usr/bin/emerge $* && exit;;

      -*h*         ) echo "remote-emerge uses exactly the same syntax as emerge:" && /usr/bin/emerge $* && exit;;

      -*p*         ) /usr/bin/emerge $* && exit;;

      -*P*         ) /usr/bin/emerge $* && exit;;

      -*s*         ) /usr/bin/emerge $* && exit;;

      -*S*         ) /usr/bin/emerge $* && exit;;

      -*V*         ) /usr/bin/emerge $* && exit;;

  esac

done

# Store a newline in a shell variable (needed by the cut command)

newline='

'

/usr/bin/emerge -fp $* 1> /dev/null 2> ~/.tempfile1

# Strip out fetch-restrict messages, turn spaces into newlines and remove blank lines (I found that on a forum and do not really get it)

cat ~/.tempfile1 | grep -v '^!!!' | cut -d " " -f 1- --output-delim="$newline" | grep -v '^$' | awk -F / '{print $NF" "$0}'z > ~/.tempfile2

rm ~/.tempfile1

# Skip files already in your DISTFILES directory and write the URLs on the amovible device

last=""

while read file url

  do

  if [ "$file" = "$last" ]

      then

      echo $url >> "$MOVINGDIR/urls/$*"

  elif [ ! -f "$DISTDIR/$file" ]

      then

      echo $url >> "$MOVINGDIR/urls/$*"

      last="$file"

  fi

done < ~/.tempfile2

rm ~/.tempfile2

# If DISTDIR already contains everything needed then install

if [ ! -f "$MOVINGDIR/urls/$*" ]

    then

    /usr/bin/emerge $*

fi

```

```
#!/bin/bash

# Distributed under the terms of the GNU General Public License v2

MOVINGDIR='/media/usbdisk/gentoo/remote-emerge'

GENTOO_MIRRORS='http://www.die.unipd.it/pub/Linux/distributions/gentoo-sources'

# Let's fetch!

for URLlist in $MOVINGDIR/urls/*

  do

  wget -nc -nd -P $MOVINGDIR/distfiles -i "$URLlist"

done

# Every list of URLs is cleaned: the sources which are eventualy fetched lead to the suppression of the related lines

for URLlist in $MOVINGDIR/urls/*

  do

  for source in $MOVINGDIR/distfiles/*

    do

    sed "/${source##*/}/d" "$URLlist" > $MOVINGDIR/.tempfile

    mv $MOVINGDIR/.tempfile "$URLlist"

  done

done

# Let's fetch the portage tree

# TODO: Store the date of the last tree that has been fetched to fetch the tree no more than once a day

for mirror in "$GENTOO_MIRRORS"

  do

  wget -nc -nd -P $MOVINGDIR $mirror/snapshots/portage-latest.tar.bz2

done

```

```
#!/bin/bash

# Distributed under the terms of the GNU General Public License v2

PORTDIR='/usr/portage'

DISTDIR='/usr/portage/distfiles'

MOVINGDIR='/mnt/usb-storage/gentoo/remote-emerge'

mv $MOVINGDIR/distfiles/* $DISTDIR

# Since most of the amovible media uses VFAT which does not implement permissions and that I love clean permissions :

chmod 644 $DISTDIR/*

for software in $MOVINGDIR/urls/*

  do

  if [ ! -s "$software" ]

      then

# This is not the distfiles directory

      emerge ${software##*/}

      rm "$software"

  fi

done

if ( test -f $MOVINGDIR/portage-latest.tar.bz2 )

    then

# There is a new Portage tree to install

# I remove the old one (but keep the precious disfiles!)

# TODO: Use rsync to gain in performance?

    for dir in $PORTDIR/*

      do

      if [ $dir != $DISTDIR ]

     then

     rm -r $dir

      fi

    done

    tar -xvjf $MOVINGDIR/portage-latest.tar.bz2 -C /usr

    emerge --metadata

    rm $MOVINGDIR/portage-latest.tar.bz2

fi

```

----------

## Il turisto

Moi j'utilise tempfile :

comme ceci :

```

fichtemp=`tempfile 2>/dev/null` || fichtemp=/tmp/test$$

trap "rm -f $fichtemp" 0 1 2 5 15

```

Je te laisse le plaisir de comprendre  :Wink: 

edit :

je me demande si dans :

```

for arg in $*

  do

  case $arg in

      --clean      ) /usr/bin/emerge $* && exit;;

      --depclean   ) /usr/bin/emerge $* && exit;;

      --help       ) echo "remote-emerge uses exactly the same syntax as emerge:" && /usr/bin/emerge $* && exit;;

      --info       ) /usr/bin/emerge $* && exit;;

      --metadata   ) /usr/bin/emerge $* && exit;;

      --pretend    ) /usr/bin/emerge $* && exit;;

      --prune      ) /usr/bin/emerge $* && exit;;

      --regen      ) /usr/bin/emerge $* && exit;;

      --search     ) /usr/bin/emerge $* && exit;;

      --searchdesc ) /usr/bin/emerge $* && exit;;

      --version    ) /usr/bin/emerge $* && exit;;

      -*c*         ) /usr/bin/emerge $* && exit;;

      -*h*         ) echo "remote-emerge uses exactly the same syntax as emerge:" && /usr/bin/emerge $* && exit;;

      -*p*         ) /usr/bin/emerge $* && exit;;

      -*P*         ) /usr/bin/emerge $* && exit;;

      -*s*         ) /usr/bin/emerge $* && exit;;

      -*S*         ) /usr/bin/emerge $* && exit;;

      -*V*         ) /usr/bin/emerge $* && exit;;

  esac

done 

```

il n'y aurait pas un prob. si je tape ton_script --pretend --search.

Il va executer 2 fois emerge --pretend --search non? à cause du /usr/bin/emerge $*

----------

## Magic Banana

Je ne suis pas certain de comprendre ce que tu veux dire. Le $* c'est l'ensemble des arguments qui sont passés à remote-emerge. Lorsque la commande demandée ne nécessite pas le réseau (par exemple si je découvre qu'elle contient un --search ou/et un --pretend), je passe le travail à /usr/bin/emerge puis sort avec la commande exit. Donc emerge n'est appelée qu'une seule fois.

Je regarde ce soir comment tu utilises tempfile et vois comment changer mes scripts pour utiliser ça. J'ai également eu il y a quelques minutes, l'idée la plus simple qu'il soit. Pourquoi m'encombrer avec MOVINGDIR dans le script remote-fetch ? Autant mettre ce script dans $MOVINGDIR (celui de remote-emerge) et utiliser des chemins relatifs. Ainsi, nous avons une variable de moins et surtout la possibilité de monter le support amovible où bon nous semble sans avoir à éditer le script.

Je considérerai ces scripts "finaux" une fois que le téléchargement de l'arbre Portage sera fait en vérifiant la date du dernier arbre décompressé et lorsque la structure des répertoires sera créée automatiquement par remote-emerge (si elle n'existe pas déjà). Si vous voulez bidouiller un peu de bash pour m'aider...

Encore une fois, mon gros problème est le temps que me prend les tests (un aller-retour labo-appartement par test). Appel à la population...

----------

## ryo-san

lut

Je suis en train d'etudier tout ca , Je serais plus a l'aise ce soir , mais déja :

```

#homesweethome

#pour choper les variables dans /etc/make.conf

PORTDIR=`grep ^PORTDIR= /etc/make.conf | sed 's/PORTDIR=//'`

DISTDIR=`grep ^DISTDIR= /etc/make.conf | sed 's/DISTDIR=//'`

...

tar -xvjfp $MOVINGDIR/portage-latest.tar.bz2 -C /usr #ajout de p pour preserver les permissions

...

```

EDIT: pour test un rep et le créer:

```

if [ ! -d $LEREP ]; then

   mkdir -p -m 755 $LEREP/{dir1,dir2,etc}

fi

```

----------

## Il turisto

 *Magic Banana wrote:*   

> Je ne suis pas certain de comprendre ce que tu veux dire. Le $* c'est l'ensemble des arguments qui sont passés à remote-emerge. Lorsque la commande demandée ne nécessite pas le réseau (par exemple si je découvre qu'elle contient un --search ou/et un --pretend), je passe le travail à /usr/bin/emerge puis sort avec la commande exit. Donc emerge n'est appelée qu'une seule fois.
> 
> 

 

Désolé je n'avais pas fais attention au fait que tu faisais exit.

Moi je peux t'aider en bash si tu as des questions mais je n'ai pas le temps de tester des scripts, ... désolé

----------

## Magic Banana

J'ai travaillé un peu hier soir.  :Wink: 

Résultats : Utilisation de tempfile, remote-fetch qui se crée automatiquement avec remote-emerge et qui utilise des chemins relatifs (le périphérique amovible peut maintenant être monté n'importe où sur la machine connectée), utilisation de /etc/make.conf pour trouver les variable PORTDIR, DISTDIR et SYNC (les grands esprits se rencontrent, n'est-ce pas ryo-san ?) et pour définir MOVINGDIR (plus besoin d'éditer les scripts).

Voilà donc les deux scripts (remote-fetch a diisparu dans remote-emerge) :

```
#!/bin/bash

# Distributed under the terms of the GNU General Public License v2

source /etc/make.conf

if [ -z $MOVINGDIR ]

    then

    echo "MOVINGDIR must be the name of a directory on an amovible device. Please set this variable in /etc/make.conf. You can, for instance, adapt the following command:

echo 'MOVINGDIR=\"/media/usbdisk/moving-portage\"' >> /etc/make.conf"

    exit

fi

# The default values for PORTDIR and DISTDIR are the one documented in the man page of make.conf

if [ -z $PORTDIR ]

    then

    PORTDIR="/usr/portage"

fi

if [ -z $DISTDIR ]

    then

    DISTDIR="${PORTDIR}/distfiles"

fi

# For any operation which does not require any fetch, use directly emerge

for arg in $*

  do

  case $arg in

      --clean      ) /usr/bin/emerge $* && exit;;

      --depclean   ) /usr/bin/emerge $* && exit;;

      --help       ) echo "remote-emerge uses exactly the same syntax as emerge:" && /usr/bin/emerge $* && exit;;

      --info       ) /usr/bin/emerge $* && exit;;

      --metadata   ) /usr/bin/emerge $* && exit;;

      --pretend    ) /usr/bin/emerge $* && exit;;

      --prune      ) /usr/bin/emerge $* && exit;;

      --regen      ) /usr/bin/emerge $* && exit;;

      --search     ) /usr/bin/emerge $* && exit;;

      --searchdesc ) /usr/bin/emerge $* && exit;;

      --version    ) /usr/bin/emerge $* && exit;;

      -*c*         ) /usr/bin/emerge $* && exit;;

      -*h*         ) echo "remote-emerge uses exactly the same syntax as emerge:" && /usr/bin/emerge $* && exit;;

      -*p*         ) /usr/bin/emerge $* && exit;;

      -*P*         ) /usr/bin/emerge $* && exit;;

      -*s*         ) /usr/bin/emerge $* && exit;;

      -*S*         ) /usr/bin/emerge $* && exit;;

      -*V*         ) /usr/bin/emerge $* && exit;;

  esac

done

# Store a newline in a shell variable (needed by the cut command)

newline='

'

tempfile1=`tempfile`

/usr/bin/emerge -fp $* 1> /dev/null 2> $tempfile1

tempfile2=`tempfile`

# Strip out fetch-restrict messages, turn spaces into newlines and remove blank lines

cat $tempfile1 | grep -v '^!!!' | cut -d " " -f 1- --output-delim="$newline" | grep -v '^$' | awk -F / '{print $NF" "$0}'z > $tempfile2

rm $tempfile1

if [ -f "$MOVINGDIR/urls/$*" ]

    then

# This command has been invoked earlier without being satisfied, remove the old urls

    rm "$MOVINGDIR/urls/$*"

fi

# Skip files already in your DISTFILES directory and write the URLs on the amovible device

last=""

while read file url

  do

  if [ "$file" = "$last" ]

      then

      echo $url >> "$MOVINGDIR/urls/$*"

  elif [ ! -f "$DISTDIR/$file" ]

      then

      echo $url >> "$MOVINGDIR/urls/$*"

      last="$file"

  fi

done < $tempfile2

rm $tempfile2

if [ -f "$MOVINGDIR/urls/$*" ]

    then

    echo '#!/bin/sh

# Distributed under the terms of the GNU General Public License v2

' > $MOVINGDIR/remote-fetch

    if [ -z $SYNC ]

   then

# The default values for SYNC is the one documented in the man page of make.conf

   echo 'SYNC="http://www.die.unipd.it/pub/Linux/distributions/gentoo-sources"' >> $MOVINGDIR/remote-fetch

    else

   echo "SYNC=$SYNC" >> $MOVINGDIR/remote-fetch

    fi

    echo '

for URLlist in urls/*

  do

  wget -nc -nd -P distfiles -i "$URLlist"

done

# Every list of URLs is cleaned: the sources which are eventualy fetched lead to the suppression of the related lines

for URLlist in urls/*

  do

  for source in distfiles/*

    do

    tempfile=`tempfile`

    sed "/${source##*/}/d" "$URLlist" > $tempfile

    mv $tempfile "$URLlist"

  done

done

# Fetch the Portage tree

# TODO: Store the date of the last tree that has been fetched to fetch the tree no more than once a day

for mirror in "$SYNC"

  do

  wget -nc -nd $mirror/snapshots/portage-latest.tar.bz2

done

' >> $MOVINGDIR/remote-fetch

    chmod 755 $MOVINGDIR/remote-fetch

    echo "From a machine connected to Internet, please run the script remote-fetch present on your amovible device."

else

# $DISTDIR already contains everything needed to proceed. Let's do it!

    /usr/bin/emerge $*

fi

```

```
#!/bin/bash

# Distributed under the terms of the GNU General Public License v2

source /etc/make.conf

if [ -z $MOVINGDIR ]

    then

    echo "MOVINGDIR must be the name of a directory on an amovible device. Please set this variable in /etc/make.conf. You can, for instance, adapt the following command:

echo 'MOVINGDIR=\"/media/usbdisk/moving-portage\"' >> /etc/make.conf"

    exit

fi

# The default values for PORTDIR and DISTDIR are the one documented in the man page of make.conf

if [ -z $PORTDIR ]

    then

    PORTDIR="/usr/portage"

fi

if [ -z $DISTDIR ]

    then

    DISTDIR="${PORTDIR}/distfiles"

fi

mv $MOVINGDIR/distfiles/* $DISTDIR

# Since most of the amovible media uses VFAT which does not implement permissions and that I love clean permissions :

chmod 644 $DISTDIR/*

for software in $MOVINGDIR/urls/*

  do

  if [ ! -s "$software" ]

      then

# This is not the distfiles directory

      emerge ${software##*/}

      rm "$software"

  fi

done

if ( test -f $MOVINGDIR/portage-latest.tar.bz2 )

    then

# There is a new Portage tree to install

# I remove the old one (but keep the precious disfiles!)

# TODO: Use rsync to gain in performance?

    for dir in $PORTDIR/*

      do

      if [ $dir != $DISTDIR ]

     then

     rm -r $dir

      fi

    done

    tar -xvjf $MOVINGDIR/portage-latest.tar.bz2 -C /usr

    emerge --metadata

    rm $MOVINGDIR/portage-latest.tar.bz2

fi

```

En lisant man make.conf j'ai découvert les arguments par défaut passés à rsync pour synchroniser l'arbre Portage. Je me pencherai sur cela ce soir si j'ai le temps.

Comme vous pouvez le constater, je travaille sur tout sauf sur ce qui est prioritaire (création automatique de l'architecture de répertoires sur le périphérique amovible et, surtout, utilisation de la date du dernier arbre Portage qui fut décompressé). Merci beaucoup à ryo-san, truc et Il turisto pour leur aide.

Est-ce que vous pensez que la structure de répertoires sur le périphérique amovible devrait être supprimée lorsque $MOVINGDIR/urls et $MOVINGDIR/distfiles sont vides ? Ca me semble pas mal (si les répertoires sont là alors remote-fetch devrait être lancé) mais ce comportement peut déstabiliser (le fameux "WTF!!!").

Pour ceux qui veulent tester, cela n'a jamais été aussi simple :

1) Vous copier les deux scripts dans des fichiers que vous rendez exécutables (chmod 755)

2) Vous créez sur le périphérique amovible (ou n'importe où si vous avez Internet et testez mon script par simple bonté  :Very Happy:  ) un répertoire qui sera MOVINGDIR et deux sous-répertoires nommés urls et distfiles

3) Vous définissez la variable MOVINGDIR dans /etc/make.conf (si vou ne le faites pas, le script vous le rappellera)

4) Tout est en place ! Vous pouvez (à plusiseurs reprises) utiliser remote-emerge exactement avec la même syntaxe que emerge. Sur la machine connectée vous lancez le script remote-fetch qui est apparu dans $MOVINGDIR. De retour sur votre Gentoo vous lancez homesweethome.

J'attends des retours. Pour être imunisé contre tout problème vous pouvez, avant toute chose, effectuer une sauvegarde de /usr/portage :

```
# cp -r /usr/portage ~
```

Pour ryo-san :

L'option p de tar ne semble pas nécessaire (en tout cas tout va pour le mieux chez moi). En fait, j'ai pris l'exacte commande recommandée par notre Bible à tous.Last edited by Magic Banana on Wed Nov 08, 2006 10:13 am; edited 1 time in total

----------

## Temet

```
  case $arg in

      --clean      ) /usr/bin/emerge $* && exit;;

      --depclean   ) /usr/bin/emerge $* && exit;;

      --help       ) echo "remote-emerge uses exactly the same syntax as emerge:" && /usr/bin/emerge $* && exit;;

      --info       ) /usr/bin/emerge $* && exit;;

      --metadata   ) /usr/bin/emerge $* && exit;;

      --pretend    ) /usr/bin/emerge $* && exit;;

      --prune      ) /usr/bin/emerge $* && exit;;

      --regen      ) /usr/bin/emerge $* && exit;;

      --search     ) /usr/bin/emerge $* && exit;;

      --searchdesc ) /usr/bin/emerge $* && exit;;

      --version    ) /usr/bin/emerge $* && exit;;

      -*c*         ) /usr/bin/emerge $* && exit;;

      -*h*         ) echo "remote-emerge uses exactly the same syntax as emerge:" && /usr/bin/emerge $* && exit;;

      -*p*         ) /usr/bin/emerge $* && exit;;

      -*P*         ) /usr/bin/emerge $* && exit;;

      -*s*         ) /usr/bin/emerge $* && exit;;

      -*S*         ) /usr/bin/emerge $* && exit;;

      -*V*         ) /usr/bin/emerge $* && exit;; 
```

Je mettrais ça

```
  case "$arg" in

      "--clean" | "-*c*"    ) /usr/bin/emerge $* && exit;;

      "--depclean"  ) /usr/bin/emerge $* && exit;;

      "--help" | "-h" ) echo "remote-emerge uses exactly the same syntax as emerge:" && /usr/bin/emerge $* && exit;;

...

```

Me demande même si c'est pas possible de faire (je ne connais pas très bien le bash, mais dans les langages courants ça se fait ):

```
  case "$arg" in

      "--clean" | "-*c*"    )

      .... (toutes les options qui crachent le même : /usr/bin/emerge $* && exit;;)

      "--version" | "-V"  ) /usr/bin/emerge $* && exit;;

      "--help" | "-h" ) echo "remote-emerge uses exactly the same syntax as emerge:" && /usr/bin/emerge $* && exit;;
```

----------

## Magic Banana

En gros tu me proposes d'économiser quelques lignes. Mouais... Je vais plutôt me concentrer sur les choses importantes. Merci quand même.  :Smile: 

----------

## Temet

Nan, j'applique le principe de "ce qui est bêtement répété ne doit pas être bêtement répété"  :Wink: 

----------

## Magic Banana

Monsieur Temet travaillerait-il avec des bases de données à longueur de journée ?  :Razz:  Si tu veux apprendre un peu de bash et éviter la redondance d'information dans remote-emerge, j'intégrerai avec plaisir tes modifications.

Tu peux aussi simplement me faire le plaisir de tester ces scripts et de me dire ce que tu en penses, si tout fonctionne bien, etc.

Moi, insister lourdement ?  :Laughing: 

----------

## Temet

Ce week end si j'ai le temps  :Wink: 

(mais je connais quasi rien en bash moi  :Mad: )

----------

## Magic Banana

En étudiant les options par défaut passées à rsync lors d'un emerge --sync, je me suis rendu compte d'un problème dans mon script dû au fait que je n'utilise pas les répertoires /usr/portage/local et /usr/portage/packages. Si vous tenez à ne pas les perdre, faites une sauvegarde de ces répertoires avant de tester homesweethome.

Autre erreur mineure, j'ai mis par défaut le mirroir italien pour télécharger le snapshot de l'arbre Portage...

Dernier problème. Il semblerait que tempfile ne soit pas une option si commune que cela puisque sur la Fedora Core 4 de mon laboratoire, elle n'est pas présente. Je pense donc revenir à l'ancienne méthode pour remote-fetch. Dois-je faire de même pour remote-emerge ou toute gentoo (à jour) a cette commande ?

----------

## kaworu

```

default='-*[cpPsSV]*|--clean|--depclean|--info|--metadata|--pretend|--prune|--regen|--search|--searchdesc|--version'

case $arg in 

    $default)

        /usr/bin/emerge $*

        exit

        ;;

    -h|--info)

        echo "remote-emerge uses exactly the same syntax as emerge:"

        /usr/bin/emerge $*

        exit

        ;;

esac 

```

ça devrait marcher (je crois hein).

----------

## Magic Banana

J'ai encore travaillé ces scripts la nuit dernière. Les deux nouveautés significatives sont :

1) La création automatique de l'arborescence sur le périphérique amovible. (Merci ryo-san)

Remarque : les répertoires urls et distfiles sont présents uniquement si ils sont peuplés.

2) Plus de flexibilté. Les listes d'URLs ne sont plus modifiées par remote-fetch. C'est maintenant homesweethomehome qui s'occupe de cela.

    2.1) Si, suite à l'exécutation de remote-fetch, le périphèrique amovible est trop plein (vis à vis d'une autre utilisation), suprimer quelques fichiers dans distfiles ne pose aucun problème.

    2.2) Si des sources sont injectées dans distfiles (celui de Gentoo ou celui du support amovible) autrement que par l'utilisation de remote-fetch, l'exécution de homesweethome supprimera les urls qui ne doivent plus être téléchargées et procédera à l'installation (ou la mise à jour) si tous les fichiers requis sont maintenant présents sur la Gentoo.

J'ai aussi fait pas mal de réécriture. J'ai notamment viré le awk que je ne maîtrise pas (copié depuis un autre script) et ai voulu faire plaisir à Temet.  :Wink:  Mais vla ti pas que je lis maintenant une revendication de kaworu pour encore moins de redondance !  :Very Happy:  J'intégrerai cela ce soir... mais il y a plus important : la gestion de la date pour savoir si oui ou non un nouvel instantanné de l'arbre Portage doit être téléchargé. J'attends vos propositions pour un script capable d'identifier le plus récent dans, par exemple, ce répertoire online. Merci par avance pour votre aide sur ce problème (dur dur d'avancer sur cette question sans passer des heures au laboratoires... sur autre chose que mon travail).

Voilà les scripts :

```
#!/bin/bash

# Distributed under the terms of the GNU General Public License v2

# AUTHOR: Magic Banana

source /etc/make.conf

if [ -z "$MOVINGDIR" ]

    then

    echo "MOVINGDIR must be the name of a directory on an amovible device. Please set this variable in /etc/make.conf. You can, for instance, adapt the following command:

echo 'MOVINGDIR=\"/media/usbdisk/moving-portage\"' >> /etc/make.conf"

    exit

fi

# The default values for PORTDIR and DISTDIR are the one documented in the man page of make.conf

if [ -z "$PORTDIR" ]

    then

    PORTDIR="/usr/portage"

fi

if [ -z "$DISTDIR" ]

    then

    DISTDIR="${PORTDIR}/distfiles"

fi

# For any operation which does not require any fetch, use directly emerge

for arg in $*

  do

  case $arg in

      --clean|-*c*      ) /usr/bin/emerge $* && exit;;

      --depclean        ) /usr/bin/emerge $* && exit;;

      --help|-*h*       ) echo "remote-emerge uses exactly the same syntax as emerge:" && /usr/bin/emerge $* && exit;;

      --info            ) /usr/bin/emerge $* && exit;;

      --metadata        ) /usr/bin/emerge $* && exit;;

      --pretend|-*p*    ) /usr/bin/emerge $* && exit;;

      --prune|-*P*      ) /usr/bin/emerge $* && exit;;

      --regen           ) /usr/bin/emerge $* && exit;;

      --search|-*s*     ) /usr/bin/emerge $* && exit;;

      --searchdesc|-*S* ) /usr/bin/emerge $* && exit;;

      --version|-*V*    ) /usr/bin/emerge $* && exit;;

  esac

done

# Create $MOVINGDIR/urls if not already there

if [ ! -d "$MOVINGDIR/urls" ]

    then

    mkdir -p -m 755 "$MOVINGDIR/urls"

fi

if [ ! -x "$MOVINGDIR/remote-fetch" ]

# First run, no date for the last Portage tree installed

# Create $MOVINGDIR/remote-fetch

    then

    echo '#!/bin/sh

# Distributed under the terms of the GNU General Public License v2

' > "$MOVINGDIR/remote-fetch"

    if [ -z "$GENTOO_MIRRORS" ]

   then

   echo 'GENTOO_MIRRORS="http://distro.ibiblio.org/pub/linux/distributions/gentoo"' >> "$MOVINGDIR/remote-fetch"

    else

   echo "GENTOO_MIRRORS=\"$GENTOO_MIRRORS\"" >> "$MOVINGDIR/remote-fetch"

    fi

    echo '

if [ -d urls ]

    then

    if [ ! -d distfiles ]

        then

        mkdir -m 755 distfiles

    fi

    for URLlist in urls/*

      do

      wget -nc -nd -P distfiles -i "$URLlist"

    done

    rmdir distfiles 2> /dev/null

fi

# Fetch the Portage tree

for mirror in "$GENTOO_MIRRORS"

  do

  wget -nc -nd "$mirror/snapshots/portage-latest.tar.bz2"

done

' >> "$MOVINGDIR/remote-fetch"

    chmod 755 "$MOVINGDIR/remote-fetch"

fi

# Store a newline in a shell variable (needed by the cut command)

newline='

'

tempfile1=`tempfile`

/usr/bin/emerge -fp $* 1> /dev/null 2> "$tempfile1"

tempfile2=`tempfile`

# Strip out fetch-restrict messages, turn spaces into newlines and remove blank lines

cat "$tempfile1" | grep -v '^!!!' | cut -d " " -f 1- --output-delim="$newline" | grep -v '^$' > "$tempfile2"

rm "$tempfile1"

if [ -f "$MOVINGDIR/urls/$*" ]

    then

# This command has been invoked earlier without being satisfied, remove the old urls

    rm "$MOVINGDIR/urls/$*"

fi

# Skip files already in $DISTDIR and write the URLs on the amovible device

last=""

while read url

  do

  if [ "${url##*/}" = "$last" ]

      then

      if [ -n "$isabsent" ]

     then

     echo "$url" >> "$MOVINGDIR/urls/$*"

      fi

  else

      if [ -f "$DISTDIR/${url##*/}" ]

     then

     isabsent=""

      else

     echo "$url" >> "$MOVINGDIR/urls/$*"

     isabsent="t"

      fi

      last="${url##*/}"

  fi

done < "$tempfile2"

rm "$tempfile2"

if [ -f "$MOVINGDIR/urls/$*" ]

    then

    echo "From a machine connected to Internet, please run the script remote-fetch present on your amovible device."

else

    rmdir --ignore-fail-on-non-empty "$MOVINGDIR/urls"

# $DISTDIR already contains everything needed to proceed. Let's do it!

    /usr/bin/emerge $*

fi

```

```
#!/bin/bash

# Distributed under the terms of the GNU General Public License v2

# AUTHOR: Magic Banana

source /etc/make.conf

if [ -z "$MOVINGDIR" ]

    then

    echo "MOVINGDIR must be the name of a directory on an amovible device. Please set this variable in /etc/make.conf. You can, for instance, adapt the following command:

echo 'MOVINGDIR=\"/media/usbdisk/moving-portage\"' >> /etc/make.conf"

    exit

fi

# The default values for PORTDIR and DISTDIR are documented in the man page of make.conf

if [ -z "$PORTDIR" ]

    then

    PORTDIR="/usr/portage"

fi

if [ -z "$DISTDIR" ]

    then

    DISTDIR="${PORTDIR}/distfiles"

fi

if [ -d "$MOVINGDIR/distfiles" ]

    then

    mv $MOVINGDIR/distfiles/* "$DISTDIR"

    rmdir "$MOVINGDIR/distfiles"

# I love clean permissions :

    chmod 644 $DISTDIR/*

fi

for URLlist in $MOVINGDIR/urls/*

  do

  tempfile=`tempfile`

  last=""

  while read url

    do

    if [ "${url##*/}" = "$last" ]

   then

   if [ -n "$isabsent" ]

       then

       echo "$url" >> "$tempfile"

   fi

    else

   if [ -f "$DISTDIR/${url##*/}" ]

       then

       isabsent=""

   else

       echo "$url" >> "$tempfile"

       isabsent="t"

   fi

   last="${url##*/}"

    fi

  done < "$URLlist"

  if [ -s "$tempfile" ]

      then

      mv "$tempfile" "$URLlist" 2> /dev/null

  else

      rm "$tempfile"

      emerge ${URLlist##*/}

      rm "$URLlist"

  fi

done

if [ -d "$MOVINGDIR/urls" ]

    then

    rmdir --ignore-fail-on-non-empty "$MOVINGDIR/urls"

fi

if [ -f "$MOVINGDIR/portage-latest.tar.bz2" ]

    then

# There is a new Portage tree to install

# Remove the old one (but keep the precious disfiles!)

# TODO: Use rsync to gain in performance?

    for dir in $PORTDIR/*

      do

      if [ "$dir" != "$DISTDIR" ]

     then

     rm -r "$dir"

      fi

    done

    tar -xvjf "$MOVINGDIR/portage-latest.tar.bz2" -C /usr

    emerge --metadata

    rm "$MOVINGDIR/portage-latest.tar.bz2"

fi

# TODO: Complete the following ($MOVINGDIR/remote-fetch)

# Store the date of the last tree that has been fetched so that:

# a) it is not fetched more than once a day

# b) it is fetched if the newest snapshot is more recent than the one in $MOVINGDIR

echo '#!/bin/sh

# Distributed under the terms of the GNU General Public License v2

' > "$MOVINGDIR/remote-fetch"

if [ -z "$GENTOO_MIRRORS" ]

    then

    echo 'GENTOO_MIRRORS="http://distro.ibiblio.org/pub/linux/distributions/gentoo"' >> "$MOVINGDIR/remote-fetch"

else

    echo "GENTOO_MIRRORS=\"$GENTOO_MIRRORS\"" >> "$MOVINGDIR/remote-fetch"

fi

echo '

if [ -d urls ]

    then

    if [ ! -d distfiles ]

        then

        mkdir -m 755 distfiles

    fi

    for URLlist in urls/*

      do

      wget -nc -nd -P distfiles -i "$URLlist"

    done

    rmdir distfiles 2> /dev/null

fi

# Fetch the Portage tree

for mirror in "$GENTOO_MIRRORS"

  do

  wget -nc -nd "$mirror/snapshots/portage-latest.tar.bz2"

done

' >> "$MOVINGDIR/remote-fetch"

chmod 755 "$MOVINGDIR/remote-fetch"

```

Pour toi qui veux tester ces scripts :

0) Fais, pour plus de sûreté, une sauvegarde de /usr/portage :

```
# cp -r /usr/portage ~
```

1) Copie les deux scripts dans des fichiers et rend les exécutables (chmod 755)

2) Définis la variable MOVINGDIR (répertoire sur le périphérique amovible) dans /etc/make.conf (si tu le fais pas, le script te le rappellera)

Tout est en place ! Tu peux :

     a) Sur la gentoo : utiliser (à plusiseurs reprises si tu le souhaites) remote-emerge avec exactement la même syntaxe que emerge.

     b) Sur la machine connectée à Internet : exécuter le script remote-fetch qui est apparu dans $MOVINGDIR.

     c) Sur la gentoo : exécuter homesweethome.

Tous les cas d'utilisation décris dans la première contribution de ce thread et dans cette présente contribution peuvent être testés.

EDIT : Commentaires moins longs pour éviter tout problème lors de la copie des scripts pour effectuer des tests

EDIT2 : Une ligne de deboguage était restée  :Embarassed: 

----------

## blasserre

 *Magic Banana wrote:*   

>  J'attends vos propositions pour un script capable d'identifier le plus récent dans, par exemple, ce répertoire online. Merci par avance pour votre aide sur ce problème (dur dur d'avancer sur cette question sans passer des heures au laboratoires... sur autre chose que mon travail).

 

c'est loin d'être parfait mais j'ai pondu ceci :

```
#!/bin/bash

MOVINGDIR="/tmp"

MIRROR="http://www.die.unipd.it/pub/Linux/distributions/gentoo-sources"

for (( i=0 ; i<10 ; i++ ))

do

    if [ -f $MOVINGDIR/portage-`date -d "$i day ago" +%Y%m%d`.tar.bz2 ]

    then

        echo "no new portage tree, try again later"

        exit 0

    fi

    # evite a la suite de planter si il n'y a jamais eu de download

    touch $MOVINGDIR/portage-2006

    # telecharge le dernier, le renomme et touch un fichier qui empeche de le retelecharger

    echo Try to get portage dated : `date -d "$i day ago" +%Y%m%d`

    wget -nc -nd -P $MOVINGDIR $MIRROR/snapshots/portage-`date -d "$i day ago" +%Y%m%d`.tar.bz2 \

        && mv $MOVINGDIR/portage-`date -d "$i day ago" +%Y%m%d`.tar.bz2 $MOVINGDIR/portage-latest.tar.bz2 \

        && rm $MOVINGDIR/portage-2* \

        && touch $MOVINGDIR/portage-`date -d "$i day ago" +%Y%m%d`.tar.bz2 \

        && echo "portage-`date -d "$i day ago" +%Y%m%d` successfully downloaded :)" \

        && exit 0

done

echo "can't find any portage tree from last ten days :("

exit 1

```

le touch du milieu est particulièrement immonde   :Embarassed:   mais ça a l'air de rouler....

reste l'intégration avec les mirrors  :Sad:  un for dans le for ?

----------

## Magic Banana

```
for (( i=0 ; i<10 ; i++ ))

   do 

   wget -nc -nd -P $MOVINGDIR $MIRROR/snapshots/portage-`date -d "$i day ago" +%Y%m%d`.tar.bz2

done
```

Merci beaucoup blasserre pour cette partie de ton code. C'est tout ce que je recherchais. C'est pas que le reste ne me plaît pas. C'est juste que dans l'idée de mes deux scripts, remote-fetch est généré à la volée et différemment suivant qu'il est généré pour la première fois ou régénéré (La régénération de script à la volée, ça pourrait presqu'être le titre d'une thèse !  :Laughing:  ). Pour ladite regénération je changerai la condition d'arrêt du for pour y mettre la date du dernier arbre décompressé.

En fait je cherchais compliqué (genre, à partir de la liste de tout ce qui est dans le répertoire en ligne, trouver la dernière date). Merci encore blasserre !

Bon... Je viens d'identifier un nouveau problème lié au cas d'utilisation où le périphérique amovible est trop plein pour mener à terme tous les téléchargements (au hasard, je pense à tetex 3 qui est gourmand en place si l'on a qu'une petite clé USB de 128 Mo...  :Twisted Evil:  ). En fait wget ne vérifie pas, avant de commencer le téléchargement, si le disque destinataire contient suffisamment de place. Pourtant il a conscience de la taille du fichier puisqu'il l'écrit avant de commencer le téléchargement. De plus, une fois le périphérique plein, il garde le fichier à moitié téléchargé...

J'ai mon idée sur comment régler ce problème (et qui fonctionne aussi si l'utilisateur décide, pendant le téléchargement, d'écrire sur le périphérique amovible) :

1) Avant de commencer un téléchargement j'écris dans un fichier $MOVINGDIR/partial_download le nom du fichier à télécharger

2) Je télécharge (l'option -c pour continuer un télèchargement avec wget est ajoutée)

3) Si le téléchargement se finit normalement, je supprime l'entrèe dans $MOVINGDIR/partial_download. Sinon, je la laisse et je sors.

4) Lors de l'exécution de homesweethome, seules les sources qui ne sont pas référencées dans $MOVINGDIR/partial_download sont déplacées vers $DISTDIR

Mon problème se situe au point 3 : Comment savoir si wget a téléchargé le fichier jusqu'au bout ? La man page de cette comande n'indique aucune valeur de sortie... À l'aide !

----------

## Il turisto

si tu fais un 

```

if wget le_fichier;then

   echo le fichier est down

else

  echo le fichier n'est pas down

```

ca devrais marcher

----------

## Magic Banana

Je viens d'essayer. Ça ne fonctionne pas, le script continue dans le then dans les deux cas (fichier totalement téléchargé ou non). J'ai également essayer en vain de mettre la commande entre backquotes... Une autre idée ?

----------

## blasserre

 *Magic Banana wrote:*   

> Je viens d'essayer. Ça ne fonctionne pas, le script continue dans le then dans les deux cas (fichier totalement téléchargé ou non). J'ai également essayer en vain de mettre la commande entre backquotes... Une autre idée ?

 

tu peux tenter d'utiliser $? qui te donnera la valeur de sortie de la dernière commande

mais ce que tu veux c'est grosso modo ce que fait mon script non ? la partie toute sale avec les && en cascade ^^

sinon c'est l'option -nc qui te mets dans le caca, remplace la par -N

----------

## Magic Banana

Non. C'est totalement un autre problème qui ne concerne pas seulement le snapshot de l'arbre Portage mais tous les fichiers téléchargés. Lorsque le périphérique amovible est plein wget s'arrête en laissant un fichier incomplet.

Je viens d'essayer d'utiliser $? pour récupérer la valeur de sortie de wget. Que le téléchargement se termine ou non, c'est 0.

Il faut donc chercher ailleurs que du côté du retour de wget pour savoir si le téléchargement est complet... Mais où ?

----------

## blasserre

chez moi ça marche   :Razz:   *Quote:*   

> 
> 
> $ wget -nc -nd -P /media/sdc http://rantanplan/gentoo/distfiles/gettext-1.03.tar.gz ; echo "retour >> $?"
> 
> --20:18:00--  http://rantanplan/gentoo/distfiles/gettext-1.03.tar.gz
> ...

 

----------

## Magic Banana

Serait-ce une bizzarerie de la Fedora Core 4 que j'utilise au laboratoire ?

----------

## blasserre

là je ne peux pas te dire, je n'utilise que de vraies distribs  :Mr. Green: 

EDIT : mais dis-donc ? t'es encore au labo à 20h30 toi   :Confused:   tu me feras le plaisir d'aller profiter un peu des latines 

----------

## Il turisto

Je suis quasi sur que le if fonctionne car je l'ai déjà utilisé dans des scripts. Sous gentoo le wget renvoie bien le code d'erreur.

----------

## Magic Banana

Effectivement... Je ne sais pas ce que j'ai fait hier !  :Embarassed:  Aujourd'hui j'ai bien le comportement voulu.

Bon... Je n'ai pas fait travaillé mes scripts hier soir pour deux raisons. La première est que j'ai "profité un peu des latines" (pour citer blasserre). La seconde est que depuis que je suis sans Internet, je n'ai jamais autant installé de chose !  :Very Happy:  Test de mes scripts oblige. Du coup hier, j'ai installé xmoto et je dois dire qu'il est bien sympa ce p'tit jeu !  :Very Happy: 

----------

## Il turisto

Tu parles. Tu dis que tu as essayé alors que tu regardais mes jolies compatriotes par la fenêtre.

Pas bien...

Fais attention quand même car elles dominent les filles la bas  :Smile: .

Bon je sors installer xmoto moi (une fois que beryl aura fini de compiler).

----------

## Magic Banana

En fait, c'est pas une latine italienne mais une latine brésilienne... Je suis comme ça moi. Lorsque j'étais au Danemark j'étais avec une russe, lorsque je suis en Italie, je suis avec une brésilienne.  :Very Happy: 

----------

## Magic Banana

Je passe au laboratoire dans l'espoir que quelques uns d'entre vous prennent le temps de tester un peu la dernière version de mon script.

J'ai bien travaillé et suis assez fier du résultat !  :Razz:  Toutes les fonctions souhaitées sont implémentées. En fait je ne vois rien de plus à ajouter !  :Razz: 

Il n'y a maintenant plus qu'un seul long script qui dissimule les trois précédents :

```
#!/bin/bash

# Distributed under the terms of the GNU General Public License v2

# AUTHOR: Magic Banana

# Variables definitions

source /etc/make.globals

source /etc/make.conf

if [ -z "$MOVINGDIR" ]

    then

    echo "MOVINGDIR must be the name of a directory on an amovible device. Please set this variable in /etc/make.conf. You can, for instance, adapt the following command:

echo 'MOVINGDIR=\"/media/usbdisk/moving-portage\"' >> /etc/make.conf"

    exit

fi

# If there is a distfiles directory on the amovible device copy its content in "$DISTDIR"

if [ ! -d "$MOVINGDIR" ]

    then

    mkdir -p -m 755 "$MOVINGDIR"

elif [ -d "$MOVINGDIR"/distfiles ]

    then

    for sourcefile in "$MOVINGDIR"/distfiles/*

      do

      if ! grep "${sourcefile##*/}" "$MOVINGDIR"/partial_fetch &> /dev/null

     then

     mv "$sourcefile" "$DISTDIR"

      fi

    done

# I love clean permissions :

    chmod 644 "$DISTDIR"/*

fi

# remote-emerge --oldactions

if [ "$*" = "--oldactions" ]

    then

    if [ -d "$MOVINGDIR"/urls ]

   then

   for URLlist in "$MOVINGDIR"/urls/*

     do

     remote-emerge "${URLlist##*/}"

   done

    fi

    SNAPSHOT=`ls "$MOVINGDIR"/portage-[2-9][0-9][0-9][0-9][0-1][0-9][0-3][0-9].tar.bz2 2> /dev/null`

    if [ -n "$SNAPSHOT" ]

   then

# There is a new Portage tree

   if ! grep ^portage$ "$MOVINGDIR"/partial_fetch &> /dev/null

       then

# It was totally downloaded

# Remove the old one (but keep the precious disfiles, the packages and the rpms)

       for file in "$PORTDIR"/*

         do

         if [ "$file" != "$DISTDIR" -a "$file" != "$PKGDIR" -a "$file" != "$RPMDIR" ]

        then

        rm -rf "$file"

         fi

       done

# Install the new Portage tree

       tar -xvjf "$SNAPSHOT" -C "$PORTDIR"/..

# Update Portage cache

       /usr/bin/emerge --metadata

       rm "$SNAPSHOT"

   fi

    fi

else

# For any operation which does not require any fetch, use directly emerge

    for arg in $*

      do

      case $arg in

     --help|-*h*       ) echo "

remote-emerge allows you to administrate offline your system in exactly the

same way and with the same syntax as emerge. However the option --sync is not

used since fetching the Portage tree is considered as a permanent request.

To perform every action previously requested and synchronize your Portage

tree (in the limit of what has been fetched), symply run

'remote-emerge --oldactions'." && /usr/bin/emerge $* && exit;;

     --oldactions      ) echo "

To perform every action previously requested and synchronize your Portage

tree (in the limit of what has been fetched), symply run

'remote-emerge --oldactions' without other option." && exit;;

     --sync            ) echo "

The option --sync is not used since fetching the Portage is considered

as a permanent request. To perform every action previously requested and

synchronize your Portage tree (in the limit of what has been fetched),

symply run 'remote-emerge --oldactions'." && exit;;

     --version|-*V*    ) echo "remote-emerge 0.1" && /usr/bin/emerge $* && exit;;

     --clean|--depclean|--info|--metadata|--pretend|--prune|--regen|--search|--searchdesc|-*c*|-*p*|-*P*|-*s*|-*S* ) /usr/bin/emerge $* && exit;;

      esac

    done

# Create "$MOVINGDIR"/urls if not already there

    if [ ! -d "$MOVINGDIR"/urls ]

   then

   mkdir -m 755 "$MOVINGDIR"/urls

    fi

# Create the list of urls to fetch in order to perform the requested action

    newline='

'

    tempfile1=`tempfile`

    /usr/bin/emerge -fp $* 1> /dev/null 2> "$tempfile1"

    tempfile2=`tempfile`

# Strip out fetch-restrict messages, turn spaces into newlines and remove blank lines

    cat "$tempfile1" | grep -v '^!!!' | cut -d " " -f 1- --output-delim="$newline" | grep -v '^$' > "$tempfile2"

    rm "$tempfile1"

    if [ -f "$MOVINGDIR/urls/$*" ]

   then

# This command has been invoked earlier without being satisfied, remove the old urls

   rm "$MOVINGDIR/urls/$*"

    fi

# Skip files already in "$DISTDIR" and write the URLs on the amovible device

    last=""

    while read url

      do

      if [ "${url##*/}" = "$last" ]

     then

     if [ -n "$isabsent" ]

         then

         echo "$url" >> "$MOVINGDIR/urls/$*"

     fi

      else

     if [ -f "$DISTDIR/${url##*/}" ]

         then

         isabsent=""

     else

         echo "$url" >> "$MOVINGDIR/urls/$*"

         isabsent="t"

     fi

     last="${url##*/}"

      fi

    done < "$tempfile2"

    if [ -f "$MOVINGDIR/urls/$*" ]

   then

   echo "From a machine connected to Internet, please run the script remote-fetch present on your amovible device."

    else

   rmdir --ignore-fail-on-non-empty "$MOVINGDIR"/urls

# "$DISTDIR" already contains everything needed to proceed. Let's do it!

   /usr/bin/emerge $*

    fi

    rm "$tempfile2"    

fi

# "$MOVINGDIR"/remote-fetch

if [ -n "$SNAPSHOT" -o ! -x "$MOVINGDIR"/remote-fetch ]

    then

# Update or create (first run) "$MOVINGDIR"/remote-fetch

    echo '#!/bin/sh

# Distributed under the terms of the GNU General Public License v2

' > "$MOVINGDIR"/remote-fetch

    echo "GENTOO_MIRRORS=\"$GENTOO_MIRRORS\"" >> "$MOVINGDIR"/remote-fetch

    if [ -n "$SNAPSHOT" ]

   then

   SNAPSHOT_FILE=${SNAPSHOT##*/}

   echo "LAST_SNAPSHOT_INSTALLED=${SNAPSHOT_FILE:8:8}" >> "$MOVINGDIR"/remote-fetch

    else

   echo "LAST_SNAPSHOT_INSTALLED=0" >> "$MOVINGDIR"/remote-fetch

    fi

    echo '

# Priority for the distfiles on the Portage tree

rm -f portage-*.tar.bz2

# Fetch the distfiles

if [ -d urls ]

    then

    if [ ! -d distfiles ]

        then

        mkdir -m 755 distfiles

    fi

    lastfilefetched=""

    for URLlist in urls/*

      do

      while read url

   do

   file="${url##*/}"

   if [ "$file" != "$lastfilefetched" ]

       then

       echo "$file" >> partial_fetch

       if wget -c -nd -P distfiles "$url"

      then

      grep -v "$file" partial_fetch > .tempfile

      if [ -s .tempfile ]

          then

          mv .tempfile partial_fetch

      else

          rm partial_fetch .tempfile

      fi

      lastfilefetched="$file"      

       fi

   fi

      done < "$URLlist"

    done

    rmdir distfiles 2> /dev/null

fi

# Fetch the Portage tree

for mirror in "$GENTOO_MIRRORS"

  do

  for (( i=0, snapshotdate=`date -d "$i day ago" +%Y%m%d`; $snapshotdate != $LAST_SNAPSHOT_INSTALLED & i < 10; i++ ))

    do

    echo "portage" >> partial_fetch

    if wget -c -nd $mirror/snapshots/portage-${snapshotdate}.tar.bz2

   then

   grep -v "portage" partial_fetch > .tempfile

   if [ -s .tempfile ]

       then

       mv .tempfile partial_fetch

   else

       rm partial_fetch .tempfile

   fi

   exit

    fi

    if [ -f portage-${snapshotdate}-tar.bz2 ]

   then

# The Portage tree was only partially downloaded

   rm portage-${snapshotdate}-tar.bz2

   exit

    fi

  done

done

' >> "$MOVINGDIR"/remote-fetch

    chmod 755 "$MOVINGDIR"/remote-fetch

fi

# Cleaning

# There should not be any remaining snapshot of the Portage tree

rm -f "$MOVINGDIR"/portage-*.tar.bz2

# Update $MOVINGDIR/partial_fetch and $MOVINGDIR/distfiles/* according to $MOVINGDIR/distfiles/*

if [ -f "$MOVINGDIR"/partial_fetch -a -d "$MOVINGDIR"/urls ]

    then

# There may be some useful partial fetchs

    tempfile3=`tempfile`

    while read sourcefile

      do

      if grep -q "$sourcefile" "$MOVINGDIR"/urls/*

     then

# $sourcefile is marked to be partially fetched but is not required to fulfill any reqested action

     rm -f "$MOVINGDIR/distfiles/$sourcefile"

      else

     echo "$sourcefile" >> "$tempfile3"

      fi

    done < "$MOVINGDIR"/partial_fetch

    if [ -s "$tempfile3" ]

   then

   mv "$tempfile3" "$MOVINGDIR"/partial_fetch

    else

   rm -rf "$MOVINGDIR"/distfiles "$MOVINGDIR"/partial_fetch "$tempfile3"

    fi

else

    rm -rf "$MOVINGDIR"/distfiles "$MOVINGDIR"/partial_fetch

fi

```

Pour le tester :

1) Devenir root :

```
# su
```

2) Copier le script dans /usr/bin/remote-emerge et le rendre exécutable avec la commande suivante :

```
# chmod 755 /usr/bin/remote-emerge
```

NB : Le script s'appelant lui-même, il doit impérativement se trouver dans un répertoire de votre variable PATH

3) Définir la variable MOVINGDIR (répertoire sur le périphérique amovible) dans /etc/make.conf. Si ce n'est pas fait, le script vous le rappellera.

La commande remote-emerge a exactement la même syntaxe qu'emerge à cela près que l'option "--sync" n'est plus disponible (le script considère que la mise à jour de l'arbre Portage est une requête parmanente) et qu'une nouvelle option "--oldactions" est ajoutée pour permettre l'installation de tout ce qui a été demandé précédemment (et de l'arbre Portage). La limite de ce qui sera effectivement fait est bien entendu fixée à ce que vous aurez réussi à télécharger sur votre périphérique amovible en exécutant remote-fetch (il n'est donc pas problématique que le périphérique amovible soit un peu plein). Remote-fetch est un autre script qui se crée et se recrée sur votre périphérique amovible à chaque utilisation de remote-emerge (ne vous inquietter pas, le script s'occupe de tout, aucune action demandée ne sera oubliée). Bref, un cycle classique d'utilisation est :

1) Quelques remote-emerge "type emerge" sur la Gentoo (par exemple "remote-emerge -uDN world")

2) Exécution de remote-fetch sur une machine connectée à internet (tout *NIX fera l'affaire)

3) De retour sur la Gentoo, exécution de "remote-emerge --oldactions"

Notez qu'entre 1 et 3 vous pouvez facilement renoncer à une action en supprimant le fichier correspondant dans $MOVINGDIR/urls.

Notez également que vous pouvez sans problème d'intégrité faire de la place sur votre périphérique amovible en supprimant des sources dans $MOVINGDIR/distfiles ou en supprimant un snapshot de l'arbre Portage qui serait dans $MOVINGDIR.

J'attends vos retours. Signalez moi, tout problème ou cas d'utilisation que j'aurais oublié. Vous pouvez aussi m'écrire que tout va bien.  :Razz: 

Pour ceux qui sont intéressés un peu par le bash, il reste deux petits inconvénients (et j'aimerais en particulier trouver une solution pour le deuxième vraiment tout bête) :

1) Contrairement au distfiles, je ne veux jamais me retrouver avec un snapshot de l'arbre Portage partiellement téléchargé (je peux vous expliquer pourquoi). Or le script ne vérifie pas si il y a suffisamment de place disponible sur le périphérique amovible pour l'acueillir. Du coup, il télécharge et si la place vient à manquer il supprime ce début de fichier. Ça ressemble à une perte de temps mais bon... ça ne me traumatise pas !  :Razz: 

2) En appelant remote-emerge avec world ou system alors que rien ne doit être mis à jour, le script prend inutilement un peu trop de temps. Si vous regardez un peu le script vous allez me dire : "Il suffit de tester si $tempfile2 est vide ou non". Seulement un [ -s "$tempfile2" ] ne donne pas le bon résultat et je ne comprends pas pourquoi (peut-être que la création de fichier avec tempfile est un peu particulière). Bien sûr je pourrais essayer des technique sales (genre un grep "." "$tempfile2") mais ça me chagrine de salir ce script... Si vous avez une idée je suis preneur !

----------

## Magic Banana

Arf! On me demande de publier mon scrips et ensuite personne ne veut me donner un coup de main pour le tester...  :Crying or Very sad: 

Histoire de faire remonter le thread, voici une nouvelle version très peu différente de la précédente :

```
#!/bin/bash

# Distributed under the terms of the GNU General Public License v2

# AUTHOR: Magic Banana

# Variables definitions

source /etc/make.globals

source /etc/make.conf

if [ -z "$MOVINGDIR" ]

    then

    echo "

MOVINGDIR must be the name of a directory on an amovible device.

Please set this variable in /etc/make.conf.

You can, for instance, adapt the following command:

echo 'MOVINGDIR=\"/media/usbdisk/moving-portage\"' >> /etc/make.conf"

    exit

fi

# If there is a distfiles directory on the amovible device copy its content in "$DISTDIR"

if [ ! -d "$MOVINGDIR" ]

    then

    mkdir -p -m 755 "$MOVINGDIR"

elif [ -d "$MOVINGDIR"/distfiles ]

    then

    for sourcefile in "$MOVINGDIR"/distfiles/*

      do

      if ! grep "${sourcefile##*/}" "$MOVINGDIR"/.partial_fetch &> /dev/null

     then

     mv "$sourcefile" "$DISTDIR"

      fi

    done

# I love clean permissions :

    chmod 644 "$DISTDIR"/*

fi

# remote-emerge --oldactions

if [ "$*" = "--oldactions" ]

    then

    if [ -d "$MOVINGDIR"/urls ]

   then

   for URLlist in "$MOVINGDIR"/urls/*

     do

     remote-emerge "${URLlist##*/}"

   done

    fi

    SNAPSHOT=`ls "$MOVINGDIR"/portage-[2-9][0-9][0-9][0-9][0-1][0-9][0-3][0-9].tar.bz2 2> /dev/null`

    if [ -n "$SNAPSHOT" ]

   then

# There is a new Portage tree

   if ! grep ^portage$ "$MOVINGDIR"/.partial_fetch &> /dev/null

       then

# It was totally downloaded

# Remove the old one (but keep the precious disfiles, the packages and the rpms)

       for file in "$PORTDIR"/*

         do

         if [ "$file" != "$DISTDIR" -a "$file" != "$PKGDIR" -a "$file" != "$RPMDIR" -a "$file" != "$PORTDIR"/../local ]

        then

        rm -rf "$file"

         fi

       done

# Install the new Portage tree

       tar -xvjf "$SNAPSHOT" -C "$PORTDIR"/..

# Update Portage cache

       /usr/bin/emerge --metadata

       rm "$SNAPSHOT"

   fi

    fi

else

# For any operation which does not require any fetch, use directly emerge

    for arg in $*

      do

      case $arg in

     --help|-*h*       ) echo "

remote-emerge allows you to administrate offline your system in exactly the

same way and with the same syntax as emerge. However the option --sync is not

used since fetching the Portage tree is considered as a permanent request.

To perform every action previously requested and synchronize your Portage

tree (in the limit of what has been fetched), symply run

'remote-emerge --oldactions'." && /usr/bin/emerge $* && exit;;

     --oldactions      ) echo "

To perform every action previously requested and synchronize your Portage

tree (in the limit of what has been fetched), symply run

'remote-emerge --oldactions' without other option." && exit;;

     --sync            ) echo "

The option --sync is not used since fetching the Portage is considered

as a permanent request. To perform every action previously requested and

synchronize your Portage tree (in the limit of what has been fetched),

symply run 'remote-emerge --oldactions'." && exit;;

     --version|-*V*    ) echo "remote-emerge 0.1" && /usr/bin/emerge $* && exit;;

     --clean|--depclean|--info|--metadata|--pretend|--prune|--regen|--search|--searchdesc|-*c*|-*p*|-*P*|-*s*|-*S* ) /usr/bin/emerge $* && exit;;

      esac

    done

# Create "$MOVINGDIR"/urls if not already there

    if [ ! -d "$MOVINGDIR"/urls ]

   then

   mkdir -m 755 "$MOVINGDIR"/urls

    fi

# Create the list of urls to fetch in order to perform the requested action

    newline='

'

    tempfile1=`tempfile`

    /usr/bin/emerge -fp $* 1> /dev/null 2> "$tempfile1"

    tempfile2=`tempfile`

# Strip out fetch-restrict messages, turn spaces into newlines and remove blank lines

    cat "$tempfile1" | grep -v '^!!!' | cut -d " " -f 1- --output-delim="$newline" | grep -v '^$' > "$tempfile2"

    rm "$tempfile1"

    if [ -f "$MOVINGDIR/urls/$*" ]

   then

# This command has been invoked earlier without being satisfied, remove the old urls

   rm "$MOVINGDIR/urls/$*"

    fi

# Skip files already in "$DISTDIR" and write the URLs on the amovible device

    last=""

    while read url

      do

      if [ "${url##*/}" = "$last" ]

     then

     if [ -n "$isabsent" ]

         then

         echo "$url" >> "$MOVINGDIR/urls/$*"

     fi

      else

     if [ -f "$DISTDIR/${url##*/}" ]

         then

         isabsent=""

     else

         echo "$url" >> "$MOVINGDIR/urls/$*"

         isabsent="t"

     fi

     last="${url##*/}"

      fi

    done < "$tempfile2"

    if [ -f "$MOVINGDIR/urls/$*" ]

   then

   echo "

From a machine connected to Internet, please run the script remote-fetch

present on your amovible device."

    else

   rmdir --ignore-fail-on-non-empty "$MOVINGDIR"/urls

# "$DISTDIR" already contains everything needed to proceed. Let's do it!

   /usr/bin/emerge $*

    fi

    rm "$tempfile2"    

fi

# "$MOVINGDIR"/remote-fetch

if [ -n "$SNAPSHOT" -o ! -x "$MOVINGDIR"/remote-fetch ]

    then

# Update or create (first run) "$MOVINGDIR"/remote-fetch

    echo '#!/bin/sh

# Distributed under the terms of the GNU General Public License v2

' > "$MOVINGDIR"/remote-fetch

    echo "GENTOO_MIRRORS=\"$GENTOO_MIRRORS\"" >> "$MOVINGDIR"/remote-fetch

    if [ -n "$SNAPSHOT" ]

   then

   SNAPSHOT_FILE=${SNAPSHOT##*/}

   echo "LAST_SNAPSHOT_INSTALLED=${SNAPSHOT_FILE:8:8}" >> "$MOVINGDIR"/remote-fetch

    else

   echo "LAST_SNAPSHOT_INSTALLED=0" >> "$MOVINGDIR"/remote-fetch

    fi

    echo '

# Priority for the distfiles on the Portage tree

rm -f portage-*.tar.bz2

# Fetch the distfiles

if [ -d urls ]

    then

    if [ ! -d distfiles ]

        then

        mkdir -m 755 distfiles

    fi

    lastfilefetched=""

    for URLlist in urls/*

      do

      while read url

   do

   file="${url##*/}"

   if [ "$file" != "$lastfilefetched" ]

       then

       echo "$file" >> .partial_fetch

       if wget -T 180 -t 3 -c -nd -P distfiles "$url"

      then

      grep -v "$file" .partial_fetch > .tempfile

      if [ -s .tempfile ]

          then

          mv .tempfile .partial_fetch

      else

          rm .partial_fetch .tempfile

      fi

      lastfilefetched="$file"      

       fi

   fi

      done < "$URLlist"

    done

    rmdir distfiles 2> /dev/null

fi

# Fetch the Portage tree

for mirror in "$GENTOO_MIRRORS"

  do

  for (( i=0, snapshotdate=`date -d "$i day ago" +%Y%m%d`; $snapshotdate != $LAST_SNAPSHOT_INSTALLED & i < 10; i++ ))

    do

    echo "portage" >> .partial_fetch

    if wget -T 180 -t 3 -nd $mirror/snapshots/portage-${snapshotdate}.tar.bz2

   then

   grep -v "portage" .partial_fetch > .tempfile

   if [ -s .tempfile ]

       then

       mv .tempfile .partial_fetch

   else

       rm .partial_fetch .tempfile

   fi

   exit

    fi

    if [ -f portage-${snapshotdate}-tar.bz2 ]

   then

# The Portage tree was only partially downloaded

   rm portage-${snapshotdate}-tar.bz2

   exit

    fi

  done

done

' >> "$MOVINGDIR"/remote-fetch

    chmod 755 "$MOVINGDIR"/remote-fetch

fi

# Cleaning

# There should not be any remaining snapshot of the Portage tree

rm -f "$MOVINGDIR"/portage-*.tar.bz2

# Update $MOVINGDIR/.partial_fetch and $MOVINGDIR/distfiles/* according to $MOVINGDIR/distfiles/*

if [ -f "$MOVINGDIR"/.partial_fetch -a -d "$MOVINGDIR"/urls ]

    then

# There may be some useful partial fetchs

    tempfile3=`tempfile`

    while read sourcefile

      do

      if grep -q "$sourcefile" "$MOVINGDIR"/urls/*

     then

# $sourcefile is marked to be partially fetched but is not required to fulfill any reqested action

     rm -f "$MOVINGDIR/distfiles/$sourcefile"

      else

     echo "$sourcefile" >> "$tempfile3"

      fi

    done < "$MOVINGDIR"/.partial_fetch

    if [ -s "$tempfile3" ]

   then

   mv "$tempfile3" "$MOVINGDIR"/.partial_fetch

    else

   rm -rf "$MOVINGDIR"/distfiles "$MOVINGDIR"/.partial_fetch "$tempfile3"

    fi

else

    rm -rf "$MOVINGDIR"/distfiles "$MOVINGDIR"/.partial_fetch

fi

```

Les améliorations :

* partial_fetch est maintenant un fichier caché (l'utilisateur ne devant pas le toucher)

* Allègement des options par défaut de wget qui sont assez extrêmes

* Meilleur formatage des messages affichés dans le terminal

J'ai conscience que les lignes qui débordent (une ligne du script sur deux lignes lorsque vous copiez le script depuis votre navigateur Web) doivent poser problème. Je ne peux que vous demander de supprimer les sauts de lignes en trop...  :Embarassed:  À moins que quelqu'un est la bonté de me prêter un peu d'espace sur son serveur... (que c'est dur de ne pas avoir Internet).

Pour tester le script, c'est très simple et c'est expliqué dans ma contribution précédente. Merci d'avance !  :Wink: 

----------

## Temet

Bah le problème c'est qu'ayant internet, et vu ce qu'il faut faire juste pour le tester ... tu comprendras que ceux qui ont internet manquent d'un certain courage pour tester ça.

Si tu veux, je te fais un répertoire sur mon ftp free, mais je ne peux pas te donner le pass pour des raisons évidentes (entre autre l'accès à mes mails).

Si ca t'intéresse, tu m'envoies un mp et tu m'envoies les scripts par mail, je les mets sur ftp.

----------

## Magic Banana

 *Temet wrote:*   

> Bah le problème c'est qu'ayant internet, et vu ce qu'il faut faire juste pour le tester ... tu comprendras que ceux qui ont internet manquent d'un certain courage pour tester ça.

 

Quoi ?!

 *Magic Banana wrote:*   

> Pour le tester :
> 
> 1) Devenir root :
> 
> ```
> ...

 

Comment faire plus simple ?

Quant à l'utilisation, j'ai du mal à imaginer plus simple également !

Mais si tu as une idée pour rendre le processus encore plus simple, n'hésite pas à m'en faire part !

Merci beaucoup pour ta proposition d'hébergement ! En fait si tu pouvais copier le script par toi même et poster l'adresse dans ce thread ce serait parfait !

----------

## Temet

Bah c'était plutot la partie de sauvegarde de portage qui ne me plaisait pas.

Pour le copier/coller, je ne pourrai pas avait ce soir car là je suis sous Windows (boulot) et j'ai pas confiance pour l'encodage et les retour chariots.

Ce soir, promis .................. si j'oublie pas  :Mad: 

EDIT : et si tu me l'envoies, ça m'évite de passer 10 minutes à refaire l'indentation qui est perdue par forumage ^^

----------

## blasserre

 *Temet wrote:*   

> Bah c'était plutot la partie de sauvegarde de portage qui ne me plaisait pas.
> 
> Pour le copier/coller, je ne pourrai pas avait ce soir car là je suis sous Windows (boulot) et j'ai pas confiance pour l'encodage et les retour chariots.
> 
> Ce soir, promis .................. si j'oublie pas 
> ...

 

pareil, la sauvegarde de /usr/portage me coûte : 9Go de distfiles

/me est un peu maniaque

/me ne jette rien

par contre pour l'indentation, si tu utilisais un vrai éditeur de texte comme emacs par exemple, tu ne la perdrais pas, et même si tu la perdais un C-x h M-x indent-region RET te la remettrait

oui je sais gnagnagnagnagana... --> []

----------

## Magic Banana

 *Temet wrote:*   

> Bah c'était plutot la partie de sauvegarde de portage qui ne me plaisait pas.
> 
> Pour le copier/coller, je ne pourrai pas avait ce soir car là je suis sous Windows (boulot) et j'ai pas confiance pour l'encodage et les retour chariots.
> 
> Ce soir, promis .................. si j'oublie pas 
> ...

 

La sauvegarde de Portage c'est juste si vous ne faites pas confiance à mon script (pour les premières versions il y avait de quoi puisque vos répertoires packages, rpm et local aurait été perdus). Vous aurez remarqué que je ne parle plus de sauvegarde depuis quelques posts puisqu'il me semble qu'à présent il n'y a plus aucun risque de pertes.

Vous pouvez même avoir vos répertoires $PORTDIR et $DISTDIR où bon vous semble. C'est prévu.  :Wink: 

Bref, j'attends vos retours d'expérience.  :Wink: 

 *blasserre wrote:*   

> pour l'indentation, si tu utilisais un vrai éditeur de texte comme emacs par exemple, tu ne la perdrais pas, et même si tu la perdais un C-x h M-x indent-region RET te la remettrait
> 
> oui je sais gnagnagnagnagana... --> []

 

Ce message est adressé à Temetn'est-ce pas ? Pour ma part, j'utilise LE vrai éditeur.  :Razz:  Remarque toutefois que pour copier-coller sur Firefox, j'ouvre mon script avec gedit parce que, je sais pas chez toi, mais cette tâche ne fonctionne pas sur la Fedora du labo. Remarque, il suffirait que j'utilise LE vrai éditeur pour naviguer sur le Web.  :Twisted Evil: 

Sinon pour ce qui est du ménage dans $DISTDIR, la commande eclean (dans gentoolkit) sans l'option --destructive est très conservatrice et te permettra sans nul doute de libérer un peu de place. Je te laisse te référer à sa man page.  :Wink:  Mais peut-être que tu comptes ouvrir un musée du code source !  :Laughing: 

----------

## Temet

Les intéressés peuvent désormais se fournir à l'adresse suivante : http://goondy.free.fr/magicbanana

C'est plus mieux que le copier/coller.

(un répertoire par version ... vu le poids d'un fichier texte, tu peux faire péter les versions  :Wink: )

----------

## Magic Banana

Bon. Et bien puisque je peux faire péter les versions, je me le permets déjà !  :Razz: 

En fait remote-fetch ne fonctionnait pas comme souhaité pour le téléchargement de l'arbre Portage. Je vous passe les détails (rien de bien grâve). Du coup, j'ai modifié tout ça et voilà la version 0.1.1 ! En attendant que Temet, dans son immense bonté, upload le script sur son serveur FTP, je vous le copie ici :

```
#!/bin/bash

# Distributed under the terms of the GNU General Public License v2

# AUTHOR: Magic Banana

# Variables definitions

source /etc/make.globals

source /etc/make.conf

if [ -z "$MOVINGDIR" ]

    then

    echo "

MOVINGDIR must be the name of a directory on an amovible device.

Please set this variable in /etc/make.conf.

You can, for instance, adapt the following command:

echo 'MOVINGDIR=\"/media/usbdisk/moving-portage\"' >> /etc/make.conf"

    exit

fi

# If there is a distfiles directory on the amovible device copy its content in "$DISTDIR"

if [ ! -d "$MOVINGDIR" ]

    then

    mkdir -p -m 755 "$MOVINGDIR"

elif [ -d "$MOVINGDIR"/distfiles ]

    then

    for sourcefile in "$MOVINGDIR"/distfiles/*

      do

      if ! grep "${sourcefile##*/}" "$MOVINGDIR"/.partial_fetch &> /dev/null

     then

     mv "$sourcefile" "$DISTDIR"

      fi

    done

# I love clean permissions :

    chmod 644 "$DISTDIR"/*

fi

# remote-emerge --oldactions

if [ "$*" = "--oldactions" ]

    then

    if [ -d "$MOVINGDIR"/urls ]

   then

   for URLlist in "$MOVINGDIR"/urls/*

     do

     remote-emerge "${URLlist##*/}"

   done

    fi

    SNAPSHOT=`ls "$MOVINGDIR"/portage-[2-9][0-9][0-9][0-9][0-1][0-9][0-3][0-9].tar.bz2 2> /dev/null`

    if [ -n "$SNAPSHOT" ]

   then

# There is a new Portage tree

   if ! grep ^portage$ "$MOVINGDIR"/.partial_fetch &> /dev/null

       then

# It was totally downloaded

# Remove the old one (but keep the precious disfiles, the packages and the rpms)

       for file in "$PORTDIR"/*

         do

         if [ "$file" != "$DISTDIR" -a "$file" != "$PKGDIR" -a "$file" != "$RPMDIR" -a "$file" != "$PORTDIR"/../local ]

        then

        rm -rf "$file"

         fi

       done

# Install the new Portage tree

       tar -xvjf "$SNAPSHOT" -C "$PORTDIR"/..

# Update Portage cache

       /usr/bin/emerge --metadata

       rm "$SNAPSHOT"

   fi

    fi

else

# For any operation which does not require any fetch, use directly emerge

    for arg in $*

      do

      case $arg in

     --help|-*h*       ) echo "

remote-emerge allows you to administrate offline your system in exactly the

same way and with the same syntax as emerge. However the option --sync is not

used since fetching the Portage tree is considered as a permanent request.

To perform every action previously requested and synchronize your Portage

tree (in the limit of what has been fetched), symply run

'remote-emerge --oldactions'." && /usr/bin/emerge $* && exit;;

     --oldactions      ) echo "

To perform every action previously requested and synchronize your Portage

tree (in the limit of what has been fetched), symply run

'remote-emerge --oldactions' without other option." && exit;;

     --sync            ) echo "

The option --sync is not used since fetching the Portage is considered

as a permanent request. To perform every action previously requested and

synchronize your Portage tree (in the limit of what has been fetched),

symply run 'remote-emerge --oldactions'." && exit;;

     --version|-*V*    ) echo "

remote-emerge 0.1.1" && /usr/bin/emerge $* && exit;;

     --clean|--depclean|--info|--metadata|--pretend|--prune|--regen|--search|--searchdesc|-*c*|-*p*|-*P*|-*s*|-*S* ) /usr/bin/emerge $* && exit;;

      esac

    done

# Create "$MOVINGDIR"/urls if not already there

    if [ ! -d "$MOVINGDIR"/urls ]

   then

   mkdir -m 755 "$MOVINGDIR"/urls

    fi

# Create the list of urls to fetch in order to perform the requested action

    newline='

'

    tempfile1=`tempfile`

    /usr/bin/emerge -fp $* 1> /dev/null 2> "$tempfile1"

    tempfile2=`tempfile`

# Strip out fetch-restrict messages, turn spaces into newlines and remove blank lines

    cat "$tempfile1" | grep -v '^!!!' | cut -d " " -f 1- --output-delim="$newline" | grep -v '^$' > "$tempfile2"

    rm "$tempfile1"

    if [ -f "$MOVINGDIR/urls/$*" ]

   then

# This command has been invoked earlier without being satisfied, remove the old urls

   rm "$MOVINGDIR/urls/$*"

    fi

# Skip files already in "$DISTDIR" and write the URLs on the amovible device

    last=""

    while read url

      do

      if [ "${url##*/}" = "$last" ]

     then

     if [ -n "$isabsent" ]

         then

         echo "$url" >> "$MOVINGDIR/urls/$*"

     fi

      else

     if [ -f "$DISTDIR/${url##*/}" ]

         then

         isabsent=""

     else

         echo "$url" >> "$MOVINGDIR/urls/$*"

         isabsent="t"

     fi

     last="${url##*/}"

      fi

    done < "$tempfile2"

    if [ -f "$MOVINGDIR/urls/$*" ]

   then

   echo "

From a machine connected to Internet, please run the script remote-fetch

present on your amovible device."

    else

   rmdir --ignore-fail-on-non-empty "$MOVINGDIR"/urls

# "$DISTDIR" already contains everything needed to proceed. Let's do it!

   /usr/bin/emerge $*

    fi

    rm "$tempfile2"    

fi

# "$MOVINGDIR"/remote-fetch

if [ -n "$SNAPSHOT" -o ! -x "$MOVINGDIR"/remote-fetch ]

    then

# Update or create (first run) "$MOVINGDIR"/remote-fetch

    echo '#!/bin/sh

# Distributed under the terms of the GNU General Public License v2

' > "$MOVINGDIR"/remote-fetch

    echo "GENTOO_MIRRORS=\"$GENTOO_MIRRORS\"" >> "$MOVINGDIR"/remote-fetch

    if [ -n "$SNAPSHOT" ]

   then

   SNAPSHOT_FILE=${SNAPSHOT##*/}

   echo "LAST_SNAPSHOT_INSTALLED=${SNAPSHOT_FILE:8:8}" >> "$MOVINGDIR"/remote-fetch

    else

   echo "LAST_SNAPSHOT_INSTALLED=0" >> "$MOVINGDIR"/remote-fetch

    fi

    echo '

# Priority for the distfiles on the Portage tree

rm -f portage-*.tar.bz2

# Fetch the distfiles

if [ -d urls ]

    then

    if [ ! -d distfiles ]

        then

        mkdir -m 755 distfiles

    fi

    lastfilefetched=""

    for URLlist in urls/*

      do

      while read url

   do

   file="${url##*/}"

   if [ "$file" != "$lastfilefetched" ]

       then

       echo "$file" >> .partial_fetch

       if wget -T 180 -t 3 -c -nd -P distfiles "$url"

      then

      grep -v "$file" .partial_fetch > .tempfile

      if [ -s .tempfile ]

          then

          mv .tempfile .partial_fetch

      else

          rm .partial_fetch .tempfile

      fi

      lastfilefetched="$file"      

       fi

   fi

      done < "$URLlist"

    done

    rmdir distfiles 2> /dev/null

fi

# Fetch the Portage tree

echo "portage" >> .partial_fetch

for i in 0 1 2 3 4 5 6 7 8 9

  do

  for mirror in "$GENTOO_MIRRORS"

    do

    snapshotdate=`date -d "$i day ago" +%Y%m%d`

    if [ $snapshotdate -eq $LAST_SNAPSHOT_INSTALLED ]

   then

   grep -v "portage" .partial_fetch > .tempfile

   if [ -s .tempfile ]

       then

       mv .tempfile .partial_fetch

   else

       rm .partial_fetch .tempfile

   fi

   exit

    fi

    rm -f wget-log

    if wget -T 180 -t 3 -nd $mirror/snapshots/portage-${snapshotdate}.tar.bz2

   then

   grep -v "portage" .partial_fetch > .tempfile

   if [ -s .tempfile ]

       then

       mv .tempfile .partial_fetch

   else

       rm .partial_fetch .tempfile

   fi

   exit

    fi

    if [ -f portage-${snapshotdate}-tar.bz2 ]

   then

# The Portage tree was only partially downloaded (I assume that the amovible device is full)

   rm portage-${snapshotdate}-tar.bz2

   grep -v "portage" .partial_fetch > .tempfile

   if [ -s .tempfile ]

       then

       mv .tempfile .partial_fetch

   else

       rm .partial_fetch .tempfile

   fi

   exit

    fi

  done

done

' >> "$MOVINGDIR"/remote-fetch

    chmod 755 "$MOVINGDIR"/remote-fetch

fi

# Cleaning

# There should not be any remaining snapshot of the Portage tree

rm -f "$MOVINGDIR"/portage-*.tar.bz2

# Update $MOVINGDIR/.partial_fetch and $MOVINGDIR/distfiles/* according to $MOVINGDIR/distfiles/*

if [ -f "$MOVINGDIR"/.partial_fetch -a -d "$MOVINGDIR"/urls ]

    then

# There may be some useful partial fetchs

    tempfile3=`tempfile`

    while read sourcefile

      do

      if [ "$sourcefile" != "portage" ]

     then

     if grep -q "$sourcefile" "$MOVINGDIR"/urls/*

         then

# $sourcefile is marked to be partially fetched but is not required to fulfill any reqested action

         rm -f "$MOVINGDIR/distfiles/$sourcefile"

     else

         echo "$sourcefile" >> "$tempfile3"

     fi

      fi

    done < "$MOVINGDIR"/.partial_fetch

    if [ -s "$tempfile3" ]

   then

   mv "$tempfile3" "$MOVINGDIR"/.partial_fetch

    else

   rm -rf "$MOVINGDIR"/distfiles "$MOVINGDIR"/.partial_fetch "$tempfile3"

    fi

else

    rm -rf "$MOVINGDIR"/distfiles "$MOVINGDIR"/.partial_fetch

fi

```

----------

## Temet

Fait  :Wink: 

----------

## Magic Banana

Voilà la version 0.2 de remote-emerge !

Les deux problèmes évoqués précédemment ont été résolus. En fait le problème des téléchargements intérompus par manque de place sur le périphérique amovible ont été repensés en profondeur (remote-fetch a été totalement refondé) et l'approche suivie est, je pense, optimale. Un début de téléchargement pouvant être utile dans le futur n'est supprimé que si la place vient à manquer et suivant la précédence : vieux snapshot incomplet < moins vieux snapshot incomplet < distfile (jamais supprimé).

De plus "remote-emerge --oldactions" maintenant indique les actions en attente d'un téléchargement et quelques bugs ont été corrigés (notamment concernant le téléchargement de l'arbre Portage).

Les sources sont gentiment mises à disposition par Temet sur son serveur FTP. Si jamais ce serveur était down, les voici :

```
#!/bin/bash

# Distributed under the terms of the GNU General Public License v2

# AUTHOR: Magic Banana

# Exit status codes

EX_OK=0

EX_USAGE=64

# Variables definitions

source /etc/make.globals

source /etc/make.conf

if [ -z "$MOVINGDIR" ]

    then

    echo "

MOVINGDIR must be the name of a directory on an amovible device.

Please set this variable in /etc/make.conf.

You can, for instance, adapt the following command:

echo 'MOVINGDIR=\"/media/usbdisk/moving-portage\"' >> /etc/make.conf"

    exit $EX_USAGE

fi

# If there is a distfiles directory on the amovible device copy its content in "$DISTDIR"

if [ ! -d "$MOVINGDIR"/distfiles ]

    then

    mkdir -p -m 755 "$MOVINGDIR"/distfiles

else

    for sourcefile in "$MOVINGDIR"/distfiles/*

      do

      if ! grep "${sourcefile##*/}" "$MOVINGDIR"/.partial_fetch &> /dev/null

     then

     mv "$sourcefile" "$DISTDIR" 2> /dev/null

      fi

    done

# I love clean permissions :

    chmod 644 "$DISTDIR"/*

fi

# remote-emerge --oldactions

if [ "$*" = "--oldactions" ]

    then

    if [ -d "$MOVINGDIR"/urls ]

   then

   for URLlist in "$MOVINGDIR"/urls/*

     do

     remote-emerge "${URLlist##*/}"

   done

    fi

    snapshot=`ls "$MOVINGDIR"/portage-[2-9][0-9][0-9][0-9][0-1][0-9][0-3][0-9].tar.bz2 2> /dev/null | awk 'NR==1 {print}'`

    if test -n "$snapshot" && ! grep ^${snapshot}$ "$MOVINGDIR"/.partial_fetch &> /dev/null

   then

# A new snapshot was totally downloaded

# Remove the one currently installed (but keep the precious disfiles, the packages, the rpms and the local directory)

       for file in "$PORTDIR"/*

         do

         if [ "$file" != "$DISTDIR" -a "$file" != "$PKGDIR" -a "$file" != "$RPMDIR" -a "$file" != "$PORTDIR"/../local ]

        then

        rm -rf "$file"

         fi

       done

# Install the new Portage tree

       tar -xvjf "$snapshot" -C "$PORTDIR"/..

# Update Portage cache

       /usr/bin/emerge --metadata

       rm "$snapshot"

    fi

else

# For any operation which does not require any fetch, use directly emerge

    for arg in $*

      do

      case $arg in

     --help|-*h*       ) echo "

remote-emerge allows you to administrate offline your system in exactly the

same way and with the same syntax as emerge. However the option --sync is not

used since fetching the Portage tree is considered as a permanent request.

To perform every action previously requested and synchronize your Portage

tree (in the limit of what has been fetched), symply run

'remote-emerge --oldactions'." && /usr/bin/emerge $* && exit $EX_OK;;

     --oldactions      ) echo "

To perform every action previously requested and synchronize your Portage

tree (in the limit of what has been fetched), symply run

'remote-emerge --oldactions' without other option." && exit $EX_USAGE;;

     --sync            ) echo "

The option --sync is not used since fetching the Portage is considered

as a permanent request. To perform every action previously requested and

synchronize your Portage tree (in the limit of what has been fetched),

symply run 'remote-emerge --oldactions'." && exit $EX_USAGE;;

     --version|-*V*    ) echo "remote-emerge 0.2" && /usr/bin/emerge $* && exit $EX_OK;;

     --clean|--depclean|--info|--metadata|--pretend|--prune|--regen|--search|--searchdesc|-*c*|-*p*|-*P*|-*s*|-*S* ) /usr/bin/emerge $* && exit $EX_OK;;

      esac

    done

# Create "$MOVINGDIR"/urls if not already there

    if [ ! -d "$MOVINGDIR"/urls ]

   then

   mkdir -m 755 "$MOVINGDIR"/urls

    fi

# Create the list of urls to fetch in order to perform the requested action

    newline='

'

    tempfile1=`tempfile`

    /usr/bin/emerge -fp $* 1> /dev/null 2> "$tempfile1"

    tempfile2=`tempfile`

# Strip out fetch-restrict messages, turn spaces into newlines and remove blank lines

    if cat "$tempfile1" | grep -v "^!!!" | cut -d " " -f 1- --output-delim="$newline" | grep -v "^$" > "$tempfile2"

   then

   if [ -f "$MOVINGDIR/urls/$*" ]

       then

# This command has been invoked earlier without being satisfied, remove the old urls

       rm "$MOVINGDIR/urls/$*"

   fi

# Skip files already in "$DISTDIR" and write the URLs on the amovible device

   last=""

   while read url

     do

     if [ "${url##*/}" = "$last" ]

         then

         if [ -n "$isabsent" ]

        then

        echo "$url" >> "$MOVINGDIR/urls/$*"

         fi

     else

         if [ -f "$DISTDIR/${url##*/}" ]

        then

        isabsent=""

         else

        echo "$url" >> "$MOVINGDIR/urls/$*"

        isabsent="t"

         fi

         last="${url##*/}"

     fi

   done < "$tempfile2"

   if [ -f "$MOVINGDIR/urls/$*" ]

       then

       echo "

'remote-emerge $*' requires the execution of the file

remote-fetch (on your amovible device) from a machine connected to Internet."

   else

       rmdir --ignore-fail-on-non-empty "$MOVINGDIR"/urls

# "$DISTDIR" already contains everything needed to proceed. Let's do it!

       /usr/bin/emerge $*

   fi

    fi

    rm "$tempfile1" "$tempfile2"

fi

# "$MOVINGDIR"/remote-fetch

if [ -n "$snapshot" -o ! -x "$MOVINGDIR"/remote-fetch ]

    then

# Update or create (first run) "$MOVINGDIR"/remote-fetch

    tempfile3=`tempfile`

    echo '#!/bin/sh

# Distributed under the terms of the GNU General Public License v2

' > "$tempfile3"

    echo "GENTOO_MIRRORS=\"$GENTOO_MIRRORS\"" >> "$tempfile3"

    if [ -n "$snapshot" ]

   then

   snapshotfile=${snapshot##*/}

   echo "LAST_SNAPSHOT_INSTALLED=${snapshotfile:8:8}" >> "$tempfile3"

    else

   echo "LAST_SNAPSHOT_INSTALLED=0" >> "$tempfile3"

    fi

    cat "$tempfile3" /usr/share/remote-emerge/remote-fetch > "$MOVINGDIR"/remote-fetch

    chmod 755 "$MOVINGDIR"/remote-fetch

    rm "$tempfile3"

fi

# Cleaning (in case of a deleted action)

# Update $MOVINGDIR/.partial_fetch and $MOVINGDIR/distfiles/* according to $MOVINGDIR/urls/*

if [ -f "$MOVINGDIR"/.partial_fetch -a -d "$MOVINGDIR"/urls ]

    then

# There may be some useful partial fetchs

    tempfile4=`tempfile`

    while read sourcefile

      do

      if [ "$sourcefile" != "portage-" ]

     then

     if grep -q "$sourcefile" "$MOVINGDIR"/urls/*

         then

         echo "$sourcefile" >> "$tempfile4"

     else

# $sourcefile is marked to be partially fetched but is not required to fulfill any reqested action

         rm -f "$MOVINGDIR/distfiles/$sourcefile"

     fi

      fi

    done < "$MOVINGDIR"/.partial_fetch

    if [ -s "$tempfile4" ]

   then

   mv "$tempfile4" "$MOVINGDIR"/.partial_fetch

    else

   rm -f "$MOVINGDIR"/distfiles/* "$MOVINGDIR"/.partial_fetch "$tempfile4"

    fi

else

    rm -f "$MOVINGDIR"/distfiles/* "$MOVINGDIR"/.partial_fetch

fi

```

```
rm_oldest_snapshot_exclude ()

{

    for snapshot in portage-[2-9][0-9][0-9][0-9][0-1][0-9][0-3][0-9].tar.bz2

      do

      if [ "$snapshot" != "$1" ]

     then

     rm snapshot

     return 0

      fi

    done

# No snapshot to remove

    return 1

}

delete_line_from_partial_fetch ()

{

    tempfile=`mktemp`

    grep -v ^"$1"$ .partial_fetch > $tempfile

    if [ -s $tempfile ]

   then

   mv $tempfile .partial_fetch

    else

   rm .partial_fetch $tempfile

    fi

}

fetch ()

{

    file="${1##*/}"

    if grep ^"$file"$ .partial_fetch &> /dev/null

   then

   PRESENT_PARTIALLY_FETCHED_SOURCE="t"

    fi

    if [ ! -f "$2/$file" -o -n "$PRESENT_PARTIALLY_FETCHED_SOURCE" ]

   then

# Try to fetch the source (new download or continuition of a previous one)

   if [ -z "$PRESENT_PARTIALLY_FETCHED_SOURCE" ]

       then

       echo "$file" >> .partial_fetch

   fi

   if wget -T 180 -t 3 -nd -c -P "$2" "$1"

       then

# The source was totally fetched

       delete_line_from_partial_fetch "$file"

       return 0

   else

       if [ ! -f "$2/$file" ]

      then

      delete_line_from_partial_fetch "$file"

       fi

# The source was only partially fetched

       return 1

   fi

    fi

# The source is already totally downloaded

    return 0

}

# Fetch the distfiles

if [ -d urls ]

    then

    if [ ! -d distfiles ]

        then

        mkdir -m 755 distfiles

    fi

    for URLlist in urls/*

      do

      while read url

   do

   ROOM="0"

   while [ "$ROOM" = "0" ]

     do

     ROOM="1"

     if ! fetch "$url" distfiles

         then

         ROOM=`df -P . | awk 'NR==2 {print $4}'`

         if [ "$ROOM" = "0" -a -f distfiles/"${url##*/}" ]

        then

        if ! rm_oldest_snapshot_exclude

            then

# There is no space left on the amovible device and no other portage snapshot to remove and make room

            exit $EX_IOERR

        fi

         fi

     fi

   done

      done < "$URLlist"

    done

    rmdir distfiles 2> /dev/null

fi

for i in 0 1 2 3 4 5 6 7 8 9

  do

  snapshotdate=`date -d "$i day ago" +%Y%m%d`

  if [ $snapshotdate -eq $LAST_SNAPSHOT_INSTALLED ]

      then

# No newer portage tree on Internet can be (totally) fetched

      exit $EX_OK

  fi

  for mirror in "$GENTOO_MIRRORS"

    do

    ROOM="0"

    while [ "$ROOM" = "0" ]

      do

      if fetch "$mirror"/snapshots/portage-${snapshotdate}.tar.bz2 .

     then

# Remove any older partially fetched snapshot

     for present_snapshot in `ls portage-*.tar.bz2 2> /dev/null`

       do

       if [ "$present_snapshot" \< portage-${snapshotdate}.tar.bz2 ]

      then

      rm "$present_snapshot"

       fi

     done

     exit $EX_OK

      else

     ROOM=`df -P . | awk 'NR==2 {print $4}'`

     if [ "$ROOM" = "0" -a -f portage-${snapshotdate}-tar.bz2 ]

         then

         if ! rm_oldest_snapshot_exclude portage-${snapshotdate}-tar.bz2

        then

# There is no space left on the amovible device and no other portage snapshot to remove and make room

        exit $EX_IOERR

         fi

     fi

      fi

    done

  done

done

```

Comme vous pouvez le voir, j'ai de nouveau divisé en deux fichiers mon script. Voilà la procédure d'installation (quelqu'un veut me faire un ebuild ?) :

1) Devenir root :

```
# su
```

2) Copier remote-emerge dans /usr/bin/remote-emerge et le rendre exécutable avec la commande suivante :

```
# chmod 755 /usr/bin/remote-emerge
```

NB : Le script s'appelant lui-même, il doit impérativement se trouver dans un répertoire de votre variable PATH

3) Créer le répertoire /usr/share/remote-emerge :

```
# mkdir /usr/share/remote-emerge
```

NB : Ce répertoire ne peut être changé (à moins de modifier à la main /usr/bin/remote-emerge)

4) Copier remote-fetch dans /usr/share/remote-emerge/remote-fetch

5) Définir la variable MOVINGDIR (répertoire sur le périphérique amovible) dans /etc/make.conf. Si ce n'est pas fait, le script vous le rappellera.

La commande remote-emerge a exactement la même syntaxe qu'emerge à cela près que l'option "--sync" n'est plus disponible (le script considère que la mise à jour de l'arbre Portage est une requête parmanente) et qu'une nouvelle option "--oldactions" est ajoutée pour permettre l'installation de tout ce qui a été demandé précédemment (et de l'arbre Portage). La limite de ce qui sera effectivement fait est bien entendu fixée à ce que vous aurez réussi à télécharger sur votre périphérique amovible en exécutant remote-fetch (il n'est donc pas problématique que le périphérique amovible soit un peu plein). Remote-fetch est un autre script qui se crée et se recrée sur votre périphérique amovible à chaque utilisation de remote-emerge (ne vous inquiettez pas, le script s'occupe de tout, aucune action demandée ne sera oubliée). Bref, un cycle classique d'utilisation est :

1) Quelques remote-emerge "type emerge" sur la Gentoo (par exemple "remote-emerge -uDN world")

2) Exécution de remote-fetch sur une machine connectée à internet (tout *NIX fera l'affaire)

3) De retour sur la Gentoo, exécution de "remote-emerge --oldactions"

Notez qu'entre 1 et 3 vous pouvez facilement renoncer à une action en supprimant le fichier correspondant dans le répertoire urls.

Notez également que vous pouvez sans problème d'intégrité faire de la place sur votre périphérique amovible en supprimant des sources dans le répertoire distfiles ou en supprimant un éventuel snapshot de l'arbre Portage.

Vous pouvez aussi rajouter à la main des sources dans le répertoire distfiles.

Cette version pourrait être qualifiée de release-candidate. En effet, je ne pense pas ajouter de nouvelle fonctionnalités. Une amélioration évidente (mais demandant beaucoup de travail) serait de vérifier l'intégrité des téléchargements avec les digests présents dans les snapshots de l'arbre Portage. Si quelqu'un veut s'y atteler, il est le bienvenue : remote-emerge est sous license GPL2 et est codé proprement (pour du bash).

J'espère que certains d'entre vous me donneront un coup de main en testant ce script durant le week-end. Toute remarque est la bienvenue ! Si tout semble fonctionner correctement, je posterai ce script dans le sous-forum (et probablement aussi dans la section anglophone analogue) avec une FAQ pour expliquer son utilisation/fonctionnement.

EDIT : Ajout du lien vers le serveur hébergeant remote-emergeLast edited by Magic Banana on Fri Nov 17, 2006 1:46 pm; edited 1 time in total

----------

## Temet

http://goondy.free.fr/magicbanana/remote-emerge-0.2

----------

## Magic Banana

Comme la dernière fois, je me permets une mise à jour imédiatement après la précédente (et m'excuse auprès de Temet).

Le problème ?

Avec la version précédente si il est impossible de télécharger des fichiers nécessaires à l'exécution d'une installation pour une raison autre que le périphérique amovible plein (par exemple si les serveurs sont down) et qu'en revanche vous téléchargez sans problème un nouveau snapshot Portage alors, de retour sur votre Gentoo, l'action impossible à réaliser ne sera pas réalisée (naturellement) et le nouveau snapshot sera installé. Jusque là tout va bien. Le problème est qu'il manquait l'étape de mettre à jour les urls nécessaires à l'action incomplète puisque cette liste peut avoir changée (comme l'arbre Portage évolue).

Cette nouvelle version corrige ce problème en ajoutant cette étape. En bonus les performances de remote-fetch ont été améliorées (imperceptibles !  :Laughing:  ).

En attendant que Temet mette les nouvelles sources sur son serveur, les voici :

```
#!/bin/bash

# Distributed under the terms of the GNU General Public License v2

# AUTHOR: Magic Banana

# Exit status codes

EX_OK=0

EX_USAGE=64

proceed_url_lists ()

{

    if [ -d "$MOVINGDIR"/urls ]

   then

   for URLlist in "$MOVINGDIR"/urls/*

     do

     remote-emerge "${URLlist##*/}"

   done

    fi

}

# Variables definitions

source /etc/make.globals

source /etc/make.conf

if [ -z "$MOVINGDIR" ]

    then

    echo "

MOVINGDIR must be the name of a directory on an amovible device.

Please set this variable in /etc/make.conf.

You can, for instance, adapt the following command:

echo 'MOVINGDIR=\"/media/usbdisk/moving-portage\"' >> /etc/make.conf"

    exit $EX_USAGE

fi

# If there is a distfiles directory on the amovible device copy its content in "$DISTDIR"

if [ ! -d "$MOVINGDIR"/distfiles ]

    then

    mkdir -p -m 755 "$MOVINGDIR"/distfiles

else

    for sourcefile in "$MOVINGDIR"/distfiles/*

      do

      if ! grep "${sourcefile##*/}" "$MOVINGDIR"/.partial_fetch &> /dev/null

     then

     mv "$sourcefile" "$DISTDIR" 2> /dev/null

      fi

    done

# I love clean permissions :

    chmod 644 "$DISTDIR"/*

fi

# remote-emerge --oldactions

if [ "$*" = "--oldactions" ]

    then

    proceed_url_lists

    snapshot=`ls "$MOVINGDIR"/portage-[2-9][0-9][0-9][0-9][0-1][0-9][0-3][0-9].tar.bz2 2> /dev/null | awk 'NR==1 {print}'`

    if test -n "$snapshot" && ! grep ^${snapshot}$ "$MOVINGDIR"/.partial_fetch &> /dev/null

   then

# A new snapshot was totally downloaded

# Remove the one currently installed (but keep the precious disfiles, the packages, the rpms and the local directory)

   for file in "$PORTDIR"/*

     do

     if [ "$file" != "$DISTDIR" -a "$file" != "$PKGDIR" -a "$file" != "$RPMDIR" -a "$file" != "$PORTDIR"/../local ]

         then

         rm -rf "$file"

     fi

   done

# Install the new Portage tree

   tar -xvjf "$snapshot" -C "$PORTDIR"/..

# Update Portage cache

   /usr/bin/emerge --metadata

   rm "$snapshot"

   proceed_url_lists

    fi

else

# For any operation which does not require any fetch, use directly emerge

    for arg in $*

      do

      case $arg in

     --help|-*h*       ) echo "

remote-emerge allows you to administrate offline your system in exactly the

same way and with the same syntax as emerge. However the option --sync is not

used since fetching the Portage tree is considered as a permanent request.

To perform every action previously requested and synchronize your Portage

tree (in the limit of what has been fetched), symply run

'remote-emerge --oldactions'." && /usr/bin/emerge $* && exit $EX_OK;;

     --oldactions      ) echo "

To perform every action previously requested and synchronize your Portage

tree (in the limit of what has been fetched), symply run

'remote-emerge --oldactions' without other option." && exit $EX_USAGE;;

     --sync            ) echo "

The option --sync is not used since fetching the Portage is considered

as a permanent request. To perform every action previously requested and

synchronize your Portage tree (in the limit of what has been fetched),

symply run 'remote-emerge --oldactions'." && exit $EX_USAGE;;

     --version|-*V*    ) echo "remote-emerge 0.2.1" && /usr/bin/emerge $* && exit $EX_OK;;

     --clean|--depclean|--info|--metadata|--pretend|--prune|--regen|--search|--searchdesc|-*c*|-*p*|-*P*|-*s*|-*S* ) /usr/bin/emerge $* && exit $EX_OK;;

      esac

    done

# Create "$MOVINGDIR"/urls if not already there

    if [ ! -d "$MOVINGDIR"/urls ]

   then

   mkdir -m 755 "$MOVINGDIR"/urls

    fi

# Create the list of urls to fetch in order to perform the requested action

    newline='

'

    tempfile1=`tempfile`

    /usr/bin/emerge -fp $* 1> /dev/null 2> "$tempfile1"

    tempfile2=`tempfile`

# Strip out fetch-restrict messages, turn spaces into newlines and remove blank lines

    if grep -v "^!!!" "$tempfile1" | cut -d " " -f 1- --output-delim="$newline" | grep -v "^$" > "$tempfile2"

   then

   if [ -f "$MOVINGDIR/urls/$*" ]

       then

# This command has been invoked earlier without being satisfied, remove the old urls

       rm "$MOVINGDIR/urls/$*"

   fi

# Skip files already in "$DISTDIR" and write the URLs on the amovible device

   last=""

   while read url

     do

     if [ "${url##*/}" = "$last" ]

         then

         if [ -n "$isabsent" ]

        then

        echo "$url" >> "$MOVINGDIR/urls/$*"

         fi

     else

         if [ -f "$DISTDIR/${url##*/}" ]

        then

        isabsent=""

         else

        echo "$url" >> "$MOVINGDIR/urls/$*"

        isabsent="t"

         fi

         last="${url##*/}"

     fi

   done < "$tempfile2"

   if [ -f "$MOVINGDIR/urls/$*" ]

       then

       echo "

'remote-emerge $*' requires the execution of the file

remote-fetch (on your amovible device) from a machine connected to Internet."

   else

       rmdir --ignore-fail-on-non-empty "$MOVINGDIR"/urls

# "$DISTDIR" already contains everything needed to proceed. Let's do it!

       /usr/bin/emerge $*

   fi

    fi

    rm "$tempfile1" "$tempfile2"

fi

# "$MOVINGDIR"/remote-fetch

if [ -n "$snapshot" -o ! -x "$MOVINGDIR"/remote-fetch ]

    then

# Update or create (first run) "$MOVINGDIR"/remote-fetch

    tempfile3=`tempfile`

    echo '#!/bin/sh

# Distributed under the terms of the GNU General Public License v2

' > "$tempfile3"

    echo "GENTOO_MIRRORS=\"$GENTOO_MIRRORS\"" >> "$tempfile3"

    if [ -n "$snapshot" ]

   then

   snapshotfile=${snapshot##*/}

   echo "LAST_SNAPSHOT_INSTALLED=${snapshotfile:8:8}" >> "$tempfile3"

    else

   echo "LAST_SNAPSHOT_INSTALLED=0" >> "$tempfile3"

    fi

    cat "$tempfile3" /usr/share/remote-emerge/remote-fetch > "$MOVINGDIR"/remote-fetch

    chmod 755 "$MOVINGDIR"/remote-fetch

    rm "$tempfile3"

fi

# Cleaning (in case of a deleted action)

# Update $MOVINGDIR/.partial_fetch and $MOVINGDIR/distfiles/* according to $MOVINGDIR/urls/*

if [ -f "$MOVINGDIR"/.partial_fetch -a -d "$MOVINGDIR"/urls ]

    then

# There may be some useful partial fetchs

    tempfile4=`tempfile`

    while read sourcefile

      do

      if [ "$sourcefile" != "portage-" ]

     then

     if grep -q "$sourcefile" "$MOVINGDIR"/urls/*

         then

         echo "$sourcefile" >> "$tempfile4"

     else

# $sourcefile is marked to be partially fetched but is not required to fulfill any reqested action

         rm -f "$MOVINGDIR/distfiles/$sourcefile"

     fi

      fi

    done < "$MOVINGDIR"/.partial_fetch

    if [ -s "$tempfile4" ]

   then

   mv "$tempfile4" "$MOVINGDIR"/.partial_fetch

    else

   rm -f "$MOVINGDIR"/distfiles/* "$MOVINGDIR"/.partial_fetch "$tempfile4"

    fi

else

    rm -f "$MOVINGDIR"/distfiles/* "$MOVINGDIR"/.partial_fetch

fi

```

```

rm_oldest_snapshot_exclude ()

{

    for snapshot in portage-[2-9][0-9][0-9][0-9][0-1][0-9][0-3][0-9].tar.bz2

      do

      if [ "$snapshot" != "$1" ]

     then

     rm snapshot

     return 0

      fi

    done

# No snapshot to remove

    return 1

}

delete_line_from_partial_fetch ()

{

    tempfile=`mktemp`

    grep -v ^"$1"$ .partial_fetch > $tempfile

    if [ -s $tempfile ]

   then

   mv $tempfile .partial_fetch

    else

   rm .partial_fetch $tempfile

    fi

}

fetch ()

{

    file="${1##*/}"

    if grep ^"$file"$ .partial_fetch &> /dev/null

   then

   PRESENT_PARTIALLY_FETCHED_SOURCE="t"

    fi

    if [ ! -f "$2/$file" -o -n "$PRESENT_PARTIALLY_FETCHED_SOURCE" ]

   then

# Try to fetch the source (new download or continuition of a previous one)

   if [ -z "$PRESENT_PARTIALLY_FETCHED_SOURCE" ]

       then

       echo "$file" >> .partial_fetch

   fi

   if wget -T 180 -t 3 -nd -c -P "$2" "$1"

       then

# The source was totally fetched

       delete_line_from_partial_fetch "$file"

       return 0

   else

       if [ ! -f "$2/$file" ]

      then

      delete_line_from_partial_fetch "$file"

       fi

# The source was only partially fetched

       return 1

   fi

    fi

# The source is already totally downloaded

    return 0

}

# Fetch the distfiles

if [ -d urls ]

    then

    if [ ! -d distfiles ]

        then

        mkdir -m 755 distfiles

    fi

    lastfilefetched=""

    for URLlist in urls/*

      do

      while read url

   do

   file="${url##*/}"

   if [ "$file" != "$lastfilefetched" ]

       then

       ROOM="0"

       while [ "$ROOM" = "0" ]

         do

         ROOM="1"

         if fetch "$url" distfiles

        then

        lastfilefetched="$file"

         else

        ROOM=`df -P . | awk 'NR==2 {print $4}'`

        if [ "$ROOM" = "0" -a -f distfiles/"${url##*/}" ]

            then

            if ! rm_oldest_snapshot_exclude

           then

# There is no space left on the amovible device and no other portage snapshot to remove and make room

           exit $EX_IOERR

            fi

        fi

         fi

       done

   fi

      done < "$URLlist"

    done

    rmdir distfiles 2> /dev/null

fi

for i in 0 1 2 3 4 5 6 7 8 9

  do

  snapshotdate=`date -d "$i day ago" +%Y%m%d`

  if [ $snapshotdate -eq $LAST_SNAPSHOT_INSTALLED ]

      then

# No newer portage tree on Internet can be (totally) fetched

      exit $EX_OK

  fi

  for mirror in "$GENTOO_MIRRORS"

    do

    ROOM="0"

    while [ "$ROOM" = "0" ]

      do

      if fetch "$mirror"/snapshots/portage-${snapshotdate}.tar.bz2 .

     then

# Remove any older partially fetched snapshot

     for present_snapshot in `ls portage-*.tar.bz2 2> /dev/null`

       do

       if [ "$present_snapshot" \< portage-${snapshotdate}.tar.bz2 ]

      then

      rm "$present_snapshot"

       fi

     done

     exit $EX_OK

      else

     ROOM=`df -P . | awk 'NR==2 {print $4}'`

     if [ "$ROOM" = "0" -a -f portage-${snapshotdate}-tar.bz2 ]

         then

         if ! rm_oldest_snapshot_exclude portage-${snapshotdate}-tar.bz2

        then

# There is no space left on the amovible device and no other portage snapshot to remove and make room

        exit $EX_IOERR

         fi

     fi

      fi

    done

  done

done

```

Je vous invite à relire la fin de mon message précédent (après les sources).

Merci pour votre aide.

----------

## Temet

Je me suis permis de rajouter un "#!/bin/bash" au début du deuxième script.

Il n'avait pas l'icône d'un script bash, ça m'a mis la puce  :Wink: 

http://goondy.free.fr/magicbanana/remote-emerge-0.2.1

----------

## Magic Banana

En fait, tu ne devais pas te permettre !  :Laughing: 

Le début du script (Sha-Bang compris) est pris depuis remote-emerge et me permet de stocker la liste des mirroirs Gentoo et surtout la date du dernier snapshot installé. Donc, s'il te plaît, pourrais-tu retirer ton ajout (mais garder la ligne blanche initiale pour raison esthétique sur le script généré  :Razz:  ) ? Merci.

Merci à tous ceux qui vont tester ce script durant le week-end.

----------

## Temet

Désolé   :Embarassed: 

Le boulet a corrigé sa boulette  :Crying or Very sad: 

----------

## Magic Banana

La version précédente fonctionnait bien. Toutefois, je me suis fendu de quelques ajouts finaux pour ce qui est la version 0.3 de remote-emerge :

* Supression de l'overhead pour quelquesactions (que j'avais oublié) ne nécessitant pas Internet comme "remote-emerge --unmerge" ou "remote-emerge --resume".

* Afin d'éviter la création d'une arborescence en locale si le périphérique amovible n'est pas monté, le script demande maintenant si l'abscence du répertoire $MOVINGDIR est dû à un oubli de monter ce périphérique ou non.

Encore cette fois, je l'espère, vous pourrez très bientôt télécharger les deux fichiers nécessaires à l'installation de remote-emerge depuis le serveur FTP de Temet que je remercie.

Alternativement vous pouvez les copier depuis ce message :

```
#!/bin/bash

# Distributed under the terms of the GNU General Public License v2

# AUTHOR: Magic Banana

# e-mail: magicbanana@gmail.com

# Exit status codes

EX_OK=0

EX_USAGE=64

proceed_url_lists ()

{

    if [ -d "$MOVINGDIR"/urls ]

   then

   for URLlist in "$MOVINGDIR"/urls/*

     do

     remote-emerge "${URLlist##*/}"

   done

    fi

}

# Variables definitions

source /etc/make.globals

source /etc/make.conf

if [ -z "$MOVINGDIR" ]

    then

    echo "

MOVINGDIR must be the name of a directory on an amovible device.

Please set this variable in /etc/make.conf.

You can, for instance, adapt the following command:

echo 'MOVINGDIR=\"/media/usbdisk/moving-portage\"' >> /etc/make.conf"

    exit $EX_USAGE

fi

# Check if the amovible device seems to be plugged

if [ ! -d "$MOVINGDIR" ]

    then

    firstletteranswer=""

    while [ "$firstletteranswer" != "y" -a "$firstletteranswer" != "Y" ]

      do

      echo -n "Is your amovible device mounted? [y/N] "

      read answer

      firstletteranswer=${answer:0:1}

      if [ -z "$firstletteranswer" -o "$firstletteranswer" = "n" -o "$firstletteranswer" = "N" ]

     then

     exit $EX_USAGE

      fi

    done

fi

# If there is a distfiles directory on the amovible device copy its content in "$DISTDIR"

if [ ! -d "$MOVINGDIR"/distfiles ]

    then

    mkdir -p -m 755 "$MOVINGDIR"/distfiles

else

    for sourcefile in "$MOVINGDIR"/distfiles/*

      do

      if ! grep "${sourcefile##*/}" "$MOVINGDIR"/.partial_fetch &> /dev/null

     then

     mv "$sourcefile" "$DISTDIR" 2> /dev/null

      fi

    done

# I love clean permissions :

    chmod 644 "$DISTDIR"/*

fi

# remote-emerge --oldactions

if [ "$*" = "--oldactions" ]

    then

    proceed_url_lists

    snapshot=`ls "$MOVINGDIR"/portage-[2-9][0-9][0-9][0-9][0-1][0-9][0-3][0-9].tar.bz2 2> /dev/null | awk 'NR==1 {print}'`

    if test -n "$snapshot" && ! grep ^${snapshot}$ "$MOVINGDIR"/.partial_fetch &> /dev/null

   then

# A new snapshot was totally downloaded

# Remove the one currently installed (but keep the precious disfiles, the packages, the rpms and the local directory)

   for file in "$PORTDIR"/*

     do

     if [ "$file" != "$DISTDIR" -a "$file" != "$PKGDIR" -a "$file" != "$RPMDIR" -a "$file" != "$PORTDIR"/../local ]

         then

         rm -rf "$file"

     fi

   done

# Install the new Portage tree

   tar -xvjf "$snapshot" -C "$PORTDIR"/..

# Update Portage cache

   /usr/bin/emerge --metadata

   rm "$snapshot"

   proceed_url_lists

    fi

else

# For any operation which does not require any fetch, use directly emerge

    for arg in $*

      do

      case $arg in

     --help|-*h*    ) echo "

remote-emerge allows you to administrate offline your system in exactly the

same way and with the same syntax as emerge. However the option --sync is not

used since fetching the Portage tree is considered as a permanent request.

To perform every action previously requested and synchronize your Portage

tree (in the limit of what has been fetched), symply run

'remote-emerge --oldactions'." && /usr/bin/emerge $* && exit $EX_OK;;

     --oldactions   ) echo "

To perform every action previously requested and synchronize your Portage

tree (in the limit of what has been fetched), symply run

'remote-emerge --oldactions' without any other option." && exit $EX_USAGE;;

     --sync         ) echo "

The option --sync is not used since fetching the Portage is considered

as a permanent request. To perform every action previously requested and

synchronize your Portage tree (in the limit of what has been fetched),

symply run 'remote-emerge --oldactions'." && exit $EX_USAGE;;

     --version|-*V* ) echo "remote-emerge 0.3" && /usr/bin/emerge $* && exit $EX_OK;;

     --clean|--config|--depclean|--info|--metadata|--pretend|--prune|--regen|--resume|--search|--searchdesc|--unmerge|--changelog|--tree|--usepkgonly|-*c*|-*p*|-*P*|-*s*|-*S*|-*C*|-*l*|-*t*|-*K* ) /usr/bin/emerge $* && exit $EX_OK;;

      esac

    done

# Create "$MOVINGDIR"/urls if not already there

    if [ ! -d "$MOVINGDIR"/urls ]

   then

   mkdir -m 755 "$MOVINGDIR"/urls

    fi

# Create the list of urls to fetch in order to perform the requested action

    newline="

"

    tempfile1=`tempfile`

    /usr/bin/emerge -fp $* 1> /dev/null 2> "$tempfile1"

    tempfile2=`tempfile`

# Strip out fetch-restrict messages, turn spaces into newlines and remove blank lines

    if grep -v "^!!!" "$tempfile1" | cut -d " " -f 1- --output-delim="$newline" | grep -v "^$" > "$tempfile2"

   then

   if [ -f "$MOVINGDIR/urls/$*" ]

       then

# This command has been invoked earlier without being satisfied, remove the old urls

       rm "$MOVINGDIR/urls/$*"

   fi

# Skip files already in "$DISTDIR" and write the URLs on the amovible device

   last=""

   while read url

     do

     if [ "${url##*/}" = "$last" ]

         then

         if [ -n "$isabsent" ]

        then

        echo "$url" >> "$MOVINGDIR/urls/$*"

         fi

     else

         if [ -f "$DISTDIR/${url##*/}" ]

        then

        isabsent=""

         else

        echo "$url" >> "$MOVINGDIR/urls/$*"

        isabsent="t"

         fi

         last="${url##*/}"

     fi

   done < "$tempfile2"

   if [ -f "$MOVINGDIR/urls/$*" ]

       then

       echo "

'remote-emerge $*' requires the execution of the file

remote-fetch (on your amovible device) from a machine connected to Internet."

   else

# "$DISTDIR" already contains everything needed to proceed. Do it!

       /usr/bin/emerge $*

   fi

    fi

    rm "$tempfile1" "$tempfile2"

fi

# "$MOVINGDIR"/remote-fetch

if [ -n "$snapshot" -o ! -x "$MOVINGDIR"/remote-fetch ]

    then

# Update or create (first run) "$MOVINGDIR"/remote-fetch

    tempfile3=`tempfile`

    echo '#!/bin/sh

# Distributed under the terms of the GNU General Public License v2

' > "$tempfile3"

    echo "GENTOO_MIRRORS=\"$GENTOO_MIRRORS\"" >> "$tempfile3"

    if [ -n "$snapshot" ]

   then

   snapshotfile=${snapshot##*/}

   echo "LAST_SNAPSHOT_INSTALLED=${snapshotfile:8:8}" >> "$tempfile3"

    else

   echo "LAST_SNAPSHOT_INSTALLED=0" >> "$tempfile3"

    fi

    cat "$tempfile3" /usr/share/remote-emerge/remote-fetch > "$MOVINGDIR"/remote-fetch

    chmod 755 "$MOVINGDIR"/remote-fetch

    rm "$tempfile3"

fi

# Cleaning (in case of manually deleted actions and/or Portage snapshots)

# Update $MOVINGDIR/.partial_fetch and $MOVINGDIR/distfiles/* according to $MOVINGDIR/urls/* and $MOVINGDIR (for Portage snapshots)

rmdir "$MOVINGDIR"/urls 2> /dev/null

if [ -f "$MOVINGDIR"/.partial_fetch -a -d "$MOVINGDIR"/urls ]

    then

# There may be some useful partial fetchs

    tempfile4=`tempfile`

    while read sourcefile

      do

      if test -f "$sourcefile" || grep -q "$sourcefile" "$MOVINGDIR"/urls/*

     then

     echo "$sourcefile" >> "$tempfile4"

      else

# $sourcefile is marked to be partially fetched but is not required to fulfill any reqested action

     rm -f "$MOVINGDIR/distfiles/$sourcefile"

      fi

    done < "$MOVINGDIR"/.partial_fetch

    if [ -s "$tempfile4" ]

   then

   mv "$tempfile4" "$MOVINGDIR"/.partial_fetch

    else

   rm -f "$MOVINGDIR"/distfiles/* "$MOVINGDIR"/.partial_fetch "$tempfile4"

    fi

else

    rm -f "$MOVINGDIR"/distfiles/* "$MOVINGDIR"/.partial_fetch

fi

exit $EX_OK

```

```
delete_line_from_partial_fetch ()

{

    tempfile=`mktemp`

    grep -v ^"$1"$ .partial_fetch > $tempfile

    if [ -s $tempfile ]

   then

   mv $tempfile .partial_fetch

    else

   rm .partial_fetch $tempfile

    fi

}

rm_oldest_snapshot_exclude ()

{

    for snapshot in portage-[2-9][0-9][0-9][0-9][0-1][0-9][0-3][0-9].tar.bz2

      do

      if [ "$snapshot" != "$1" ]

     then

     rm snapshot

     delete_line_from_partial_fetch "$snapshot"

     return 0

      fi

    done

# No snapshot to remove

    return 1

}

fetch ()

{

    file="${1##*/}"

    if grep ^"$file"$ .partial_fetch &> /dev/null

   then

   PRESENT_PARTIALLY_FETCHED_SOURCE="t"

    fi

    if [ ! -f "$2/$file" -o -n "$PRESENT_PARTIALLY_FETCHED_SOURCE" ]

   then

# Try to fetch the source (new download or continuition of a previous one)

   if [ -z "$PRESENT_PARTIALLY_FETCHED_SOURCE" ]

       then

       echo "$file" >> .partial_fetch

   fi

   if wget -T 180 -t 3 -nd -c -P "$2" "$1"

       then

# The source was totally fetched

       delete_line_from_partial_fetch "$file"

       return 0

   else

       if [ ! -f "$2/$file" ]

      then

      delete_line_from_partial_fetch "$file"

       fi

# The source was only partially fetched

       return 1

   fi

    fi

# The source is already totally downloaded

    return 0

}

# Fetch the distfiles

if [ -d urls ]

    then

    if [ ! -d distfiles ]

        then

        mkdir -m 755 distfiles

    fi

    lastfilefetched=""

    for URLlist in urls/*

      do

      while read url

   do

   file="${url##*/}"

   if [ "$file" != "$lastfilefetched" ]

       then

       ROOM="0"

       while [ "$ROOM" = "0" ]

         do

         ROOM="1"

         if fetch "$url" distfiles

        then

        lastfilefetched="$file"

         else

        ROOM=`df -P . | awk 'NR==2 {print $4}'`

        if [ "$ROOM" = "0" -a -f distfiles/"${url##*/}" ]

            then

            if ! rm_oldest_snapshot_exclude

           then

# There is no space left on the amovible device and no other portage snapshot to remove and make room

           exit $EX_IOERR

            fi

        fi

         fi

       done

   fi

      done < "$URLlist"

    done

    rmdir distfiles 2> /dev/null

fi

for i in 0 1 2 3 4 5 6 7 8 9

  do

  snapshotdate=`date -d "$i day ago" +%Y%m%d`

  if [ $snapshotdate -eq $LAST_SNAPSHOT_INSTALLED ]

      then

# No newer portage tree on Internet can be (totally) fetched

      exit $EX_OK

  fi

  for mirror in "$GENTOO_MIRRORS"

    do

    ROOM="0"

    while [ "$ROOM" = "0" ]

      do

      if fetch "$mirror"/snapshots/portage-${snapshotdate}.tar.bz2 .

     then

# Remove any older partially fetched snapshot

     for present_snapshot in `ls portage-*.tar.bz2 2> /dev/null`

       do

       if [ "$present_snapshot" \< portage-${snapshotdate}.tar.bz2 ]

      then

      rm "$present_snapshot"

      delete_line_from_partial_fetch "$present_snapshot"

       fi

     done

     exit $EX_OK

      else

     ROOM=`df -P . | awk 'NR==2 {print $4}'`

     if [ "$ROOM" = "0" -a -f portage-${snapshotdate}-tar.bz2 ]

         then

         if ! rm_oldest_snapshot_exclude portage-${snapshotdate}-tar.bz2

        then

# There is no space left on the amovible device and no other portage snapshot to remove and make room

        exit $EX_IOERR

         fi

     fi

      fi

    done

  done

done

exit $EX_IOERR

```

Voilà la procédure d'installation (quelqu'un veut me faire un ebuild ?) :

1) Devenir root :

```
# su
```

2) Copier remote-emerge dans /usr/bin/remote-emerge et le rendre exécutable avec la commande suivante :

```
# chmod 755 /usr/bin/remote-emerge
```

NB : Le script s'appelant lui-même, il doit impérativement se trouver dans un répertoire de votre variable PATH

3) Créer le répertoire /usr/share/remote-emerge :

```
# mkdir /usr/share/remote-emerge
```

NB : Ce répertoire ne peut être changé (à moins de modifier à la main /usr/bin/remote-emerge)

4) Copier remote-fetch dans /usr/share/remote-emerge/remote-fetch

5) Définir la variable MOVINGDIR (répertoire sur le périphérique amovible) dans /etc/make.conf. Si ce n'est pas fait, le script vous le rappellera (avec en bonus, un exemple).

La commande remote-emerge a exactement la même syntaxe qu'emerge à cela près que l'option "--sync" n'est plus disponible (le script considère que la mise à jour de l'arbre Portage est une requête parmanente) et qu'une nouvelle option "--oldactions" est ajoutée pour permettre l'installation de tout ce qui a été demandé précédemment (et de l'arbre Portage). La limite de ce qui sera effectivement fait est bien entendu fixée à ce que vous aurez réussi à télécharger sur votre périphérique amovible en exécutant remote-fetch (il n'est donc pas problématique que le périphérique amovible soit un peu plein). Remote-fetch est un autre script qui se crée et se recrée sur votre périphérique amovible à chaque utilisation de remote-emerge (ne vous inquiettez pas, le script s'occupe de tout, aucune action demandée ne sera oubliée). Bref, un cycle classique d'utilisation est :

1) Quelques remote-emerge "type emerge" sur la Gentoo (par exemple "remote-emerge -uDN world")

2) Exécution de remote-fetch sur une machine connectée à internet (tout *NIX fera l'affaire)

3) De retour sur la Gentoo, exécution de "remote-emerge --oldactions"

Notez qu'entre 1 et 3 vous pouvez facilement renoncer à une action en supprimant le fichier correspondant dans le répertoire urls.

Notez également que vous pouvez sans problème d'intégrité faire de la place sur votre périphérique amovible en supprimant des sources dans le répertoire distfiles ou en supprimant un éventuel snapshot de l'arbre Portage.

Vous pouvez aussi rajouter à la main des sources dans le répertoire distfiles.

EDIT : Version 0.3 et non 3...Last edited by Magic Banana on Tue Nov 21, 2006 10:21 am; edited 1 time in total

----------

## Temet

Quand j'ai ton mail, je le fais.

Sinon, un 'ti tarball en vue d'un ebuild? ^^

----------

## Magic Banana

Le serveur Gmail est indisponible temporairement...  :Embarassed:  Je réessaie dans un moment pour t'envoyer tout cela (un tar.bz2 aussi si tu la Fedora du labo peut me faire ça).

Pour un ebuild, je ne suis pas contre un petit coup de main. Vu la complexité de la procédure d'installation, ce ne doit pas être bien dur... mais vu que je n'ai jamais fait ça et que je ne peux pas le tester (ma Gentoo étant offline...  :Crying or Very sad:  )...

Qui se porte volontaire ?

----------

## Temet

[Maître Yoda]Le tout en ligne est[/Maître Yoda]

----------

## Magic Banana

Bon... Je viens de découvrir un nouveau problème : il est impossible de préciser le depend sous sa forme complète category/package. Par exemple remote-emerge ne permet pas, dans sa forme actuelle, l'installation de media-sound/listen (dans ce cas, la catégorie doit être spécifiée pour éviter l'ambiguité avec dev-tinyos/listen).

J'ai donc retravaillé le script hier soir (jusqu'à 2h30  :Confused:  ). Je l'ai testé rapidement pour la requête d'installation et le fetch. Ça semble fonctionner. Je rentre chez moi à midi. Si l'installation à proprement parlé se passe bien également, vous aurez droit à remote-emerge-0.3.1 dans l'après-midi.  :Wink: 

----------

## Magic Banana

Tout ne s'est pas passé pour le mieux (des problèmes de traitements des espaces dans les chaîne de caractère) mais j'ai pris le temps de corriger tout ça. Tout semble maintenant fonctionner à merveille... mais pas la forme "remote-emerge /chemin/vers/ebuild" (elle est de toute façon déconseillée dans "man emerge"). En fait je n'ai pas encore tester la forme dépendance (par exemple "remote-emerge >=dev-lang/python-2.2.1-r2") mais cela devrait fonctionner aussi (toutefois d'un point de vue esthétique ce ne doit pas être terrible puisque les ">=" vont se retrouver en préfixe du répertoire indiquant la catégorie) !

Voilà donc remote-emerge-0.3.1 ! Le serveur de Temet devrait, encore cette fois, être l'endroit où télécharger le script. Si le serveur n'est pas disponible, demandez-moi les sources par mail : magicbanana@gmail.com

Cette fois-ci, je ne publie pas ici les sources car je n'ai pas changé la ligne plus large que l'écran de Monsieur tout le monde.

Comme toujours, je redonne les informations quant à l'installation (j'attends toujours une bonne âme pour me faire un ebuild) et l'utilisation de remote-emerge :

Installation :

1) Devenir root :

```
# su
```

2) Copier remote-emerge dans /usr/bin/remote-emerge et le rendre exécutable avec la commande suivante :

```
# chmod 755 /usr/bin/remote-emerge
```

NB : Le script s'appelant lui-même, il doit impérativement se trouver dans un répertoire de votre variable PATH.

3) Créer le répertoire /usr/share/remote-emerge :

```
# mkdir /usr/share/remote-emerge
```

NB : Ce répertoire ne peut être changé (à moins de modifier à la main /usr/bin/remote-emerge).

4) Copier remote-fetch dans /usr/share/remote-emerge/remote-fetch

5) Définir la variable MOVINGDIR (répertoire sur le périphérique amovible) dans /etc/make.conf. Si ce n'est pas fait, le script vous le rappellera (avec en bonus, un exemple).

Utilisation :

La commande remote-emerge a exactement la même syntaxe qu'emerge à cela près que l'option "--sync" n'est plus disponible (le script considère que la mise à jour de l'arbre Portage est une requête quotidienne, ni plus, ni moins) et qu'une nouvelle option "--oldactions" est ajoutée pour permettre l'installation de tout ce qui a été demandé précédemment (et de l'arbre Portage). La limite de ce qui sera effectivement fait est bien entendu fixée à ce que vous aurez réussi à télécharger sur votre périphérique amovible en exécutant remote-fetch (il n'est donc pas problématique que le périphérique amovible soit un peu plein). Remote-fetch est un autre script qui se crée et se recrée sur votre périphérique amovible à chaque utilisation de remote-emerge (ne vous inquiettez pas, le script s'occupe de tout, aucune action demandée ne sera oubliée, aucune source partiellement téléchargée n'entrera dans votre Gentoo). Bref, un cycle classique d'utilisation est :

1) Quelques remote-emerge "type emerge" sur la Gentoo (par exemple "remote-emerge -uDN world" ou "remote-emerge media-sound/listen")

2) Exécution de remote-fetch (un double-clic devrait suffire) sur une machine connectée à internet (tout *NIX fera l'affaire)

3) De retour sur la Gentoo, exécution de "remote-emerge --oldactions"

Notez qu'entre 1 et 3 vous pouvez facilement renoncer à une action en supprimant le fichier correspondant dans le répertoire urls.

Notez également que vous pouvez sans problème d'intégrité faire de la place sur votre périphérique amovible en supprimant des sources dans le répertoire distfiles ou en supprimant un éventuel snapshot de l'arbre Portage.

Vous pouvez aussi rajouter à la main des sources dans le répertoire distfiles.

----------

## Temet

C'est fait ... par contre, je ne vois pas le README.fr alors qu'il est sur le serveur o_O'

EDIT : je ne comprends pas.

```
ftp> dir

227 Entering Passive Mode (212,27,63,3,47,199).

150 Opening ASCII mode data connection for file list

drwx------   2 web site      192 Nov 23 07:36 .

drwx------   8 web site      288 Nov 23 07:25 ..

-rw-r--r--   1 web site     2608 Nov 23 07:25 README.fr

-rw-r--r--   1 web site     8154 Nov 23 07:25 remote-emerge

-rw-r--r--   1 web site    10240 Nov 23 07:25 remote-emerge-0.3.1.tar.bz2

-rw-r--r--   1 web site     3383 Nov 23 07:25 remote-fetch
```

J'ai essayé de changer de nom, pareil o_O''''

----------

## kwenspc

Salut Magic Banana, ton script m'interesse vu que j'attends toujours d'avoir le net chez moi   :Evil or Very Mad: 

Pour faire un ebuid je suis ok, ça sera vraiment pas dur  :Smile:  (un coup de 10 min ça)

----------

## Temet

Je peux aussi héberger l'ebluid, je ne suis plus à ca pret ^^

----------

## Magic Banana

Merci pour ta propoition kwenspc. Et merci encore une fois à Temet d'héberger ce petit programme ! En fait je me suis déjà lancé dans la rédaction d'un ebuild (après avoir fait un un formidable install.sh de 4 lignes  :Very Happy:  ). Je ne l'ai pas encore testé car une fois sa rédaction terminée, j'ai constaté que mon test d'installation par "remote-emerge -u media-sound/listen" s'était mal passé. Encore des problèmes de gestion des chaînes de caractères...

Je l'ai corrigé. J'en ai profité pour enlever l'overhead pour l'installation direct d'un fichier .tbz2. Vous allez me dire que pour installer un .tbz2 l'intérêt d'utiliser remote-emerge plutôt qu'emerge est limité... mais j'aspire à la possibilité d'ajouter "alias emerge remote-emerge" dans mon .bashrc.  :Razz:   :Wink: 

Avant de vous livrer cette nouvelle version, laissez moi la tester de nouveau, voir si l'ebuild fonctionne et améliorer l'esthétique en cas de remote-emerge de type dépendance (comme remote-emerge >=category/package-0.1).

Attends donc un peu kwenpc et le moment venu... fait le bourrin s'il te plaît !  :Laughing:  remote-emerge est sensé géré parfaitement le fetch lorsque le périphérique amovible manque de place. Il le remplit à 100% mais ne transvasera sur ta gentoo que les sources (ou binaires) entièrement téléchargées. Il n'installera ensuite que ce qui peut être installé. Au prochain remote-fetch les téléchargements incomplets reprendront où ils s'étaient terminés. Si tu as quelque chose à ajouter sur ton périphérique amovible alors qu'il est à plein à 100% tu peux faire de la place dans distfiles sans soucis d'intégrité.

En d'autres termes :

```
# remote-emerge -uDN world
```

  :Wink: 

----------

## kwenspc

no pb, si t'as un soucis avec l'ebuild tu me fais signe   :Smile: 

----------

## Magic Banana

remote-emerge-0.4 est prêt. Des bugs ont été corrigés (notamment la gestion des espaces dans les chaînes de caractère et un problèmes de lignes disparaissant dans .partial_fetch si la source partiellement téléchargée était nécessaire à l'accomplissement d'une commande où la catégorie est précisée), l'affichage en fin de "remote-emerge --oldactions" a été sensiblement amélioré (une belle liste des commandes qui attendent l'exécution de remote-fetch) et les opérateurs logiques préfixent maintenant toujours le fichier correspondant au paquet (et non sa catégorie).

De plus j'ai écrit un ebuild (à mettre dans votre overlay) pour installer ce petit programme.

En gros la seule chose sur laquelle je compte encore travailler (autre que la résolution de bug si vous en trouver de nouveaux) est la documentation. J'ai un tout petit début de README.fr. Je devrais le compléter et faire son équivalent anglophone. Peut-être une man page (je n'ai jamais fait cela...). Si vous voulez m'aider sur ces points vous êtes le bienvenue.

Je suis donc à deux doigts de vous fournir cette nouvelle version mais voilà qu'un doute m'assaille !  :Very Happy:  Ne devrais-je pas renommer ce petit programme pour "emerge-offline" ? J'espère que ce petit script sera utilisé par d'autres que moi même (vu le temps que j'ai passé dessus et le résultat que j'estime satisfaisant) et pense que "remote-emerge" porte à confusion laissant penser que le script sert à administrer sa Gentoo depuis une autre machine. Qu'en pensez-vous ?

----------

## Magic Banana

"Qui ne dit mot consent". Ce petit programme s'appelle donc désormais offline-emerge !

Je voulais travailler sur une man page avant de vous livrer cette version mais je n'ai pas consacré beaucoup de temps à offline-emerge cette semaine. Comme le week-end arrive avec potentiellement des gentooists ayant du temps à consacrer au test de ce script...

Je transmets donc offline-emerge à Temet afin qu'il me l'héberge gentiment sur son serveur FTP. L'installation de offline-emerge peut maintenant se faire via Portage puisque que j'ai écrit un petit ebuild.  :Wink:  Il vous suffit donc de le telécharger là et de l'installer en utilisant un overlay (cf. la documentation de Portage associée).

Si vous installer offline-emerge avec le USE flag "doc", vous pourrez également avoir en local le petit texte explicatif en français que je postais dans ce thread à chaque nouvelle version. Je sais, ça ne vaut pas une man page... Je vais probablement la faire ce week-end.

Tout retour (bug, demande de fonctionnalité ou simple retour d'expérience) est le bienvenue !Last edited by Magic Banana on Fri Dec 01, 2006 11:08 am; edited 1 time in total

----------

## Mickael

Salut Magic Banana,

alors, merci pour ton boulot, et comme d'habitude j'ai pas encore testé, mais je suis obligé de passer par ton ebuild, donc attend un peu stp.

 :Wink: 

PS : merci Temet pour le serveur aussi.  :Wink: 

----------

## Temet

C'est fait.

Attention MagicBanana, dans tes liens tu as mis "ftp://" hors ce n'est pas possible avec free, tu dois mettre "http://".

Je me suis donc permis de modifier le src_uri de ton ebuild.

(j'aurais aussi mis "removable" au lieu de "amovible" mais ne me suis pas permis de spolier ton travail  :Wink: )

http://goondy.free.fr/magicbanana/offline-emerge-0.4.ebuild

http://goondy.free.fr/magicbanana/

----------

## Il turisto

Je ne sais pas si tu peux utiliser le nom d'emerge dans le nom de ton soft.

Il me semblais avoir lu que ce n'étais pas autorisé mais je suis plus sur.

----------

## Mickael

offline-update alors? ou OUP (Offline Update Portage) et même OUPR, (Rescue)....

----------

## Temet

Evidemment, fallait le dire une fois l'ebuild faite et en ligne ... vous savez que je dois me connecter en ssh sur mon pc en France pour foutre ces fichiers sur mon ftp ???????  :Twisted Evil: 

----------

## Magic Banana

Merci beaucoup Temet d'avoir modifié le SRC_URI. Il s'agit bien entendu d'une erreur (comment pourrais-je tester le fetch via emerge sans Gentoo connecté à Internet ?).

Concernant tous ces problèmes de noms :

- "Removable device" semble effectivement être le terme le plus aproprié. Je ne sais pas d'où je sors "amovible device" mais une recherche sur Google me montre que je ne suis pas seul à utiliser cette terminologie (OK, nous ne sommes pas nombreux non plus). Je change ça pour la version 0.4.1 (qui viendra je l'espère avec une belle man page).

- Il est interdit d'utiliser emerge dans le nom de la commande... Arf ! Je n'ai pas réussi à trouver confirmation de cette information. Si vous avez un lien... Le problème avec les propositions à base de "update" est qu'étant un wrapper d'emerge, offline-emerge peut faire tout ce que emerge fait (à l'exception de l'emerge en donnant le chemin d'un ebuild mais qui est de toute façon connue comme cassée dans emerge) et pas seulement les mises à jour. Pour le moment je vais donc en rester à "offline-emerge".

J'en profite pour vous prévenir d'un bug qui n'en est pas un (mais qui m'a occupé un moment !) : si vous utilisez un périphérique formaté en VFAT (comme le son la plupart des clés USB et autres lecteurs MP3), vous ne pouvez pas faire un emerge du type dépendance en utilisant les opérateur logiques "<" ou ">". Je m'explique (parce que ce n'est pas une action super courrante non plus) : si vous faites "offline-emerge <dev-lang/php-5", offline-emerge tente de créer un fichier nommé "<php-5" sur votre clé USB (ou autre). Or les caractères "<" ou ">" ne peuvent pas figurer dans un nom de fichier sur VFAT. La parade ? Soit vous faites une partition ext2 (qui, si j'ai bien compris, est lisible depuis Winblows), soit vous lancez "offline-emerge -p <dev-lang/php-5" puis, d'après le résultat, "offline-emerge =dev-lang/php-4.4.4-r6" (le caractère '=' ne posant pas de problème).

----------

## Temet

Figura ti  :Wink: 

Pour une fois que je peux apporter une aide (même dérisoire) à quelque chose ...

----------

## Il turisto

Pour préciser je suis sur que le mot gentoo étais interdit et emerge et portage aussi je crois.

Mais pour ces 2 derniers je ne suis plus sur du tout.

----------

## Magic Banana

Pour le nom Gentoo j'ai réussi à trouver une confirmation par source officielle (c'était pas bien dur). Pour "emerge", rien d'équivalent ne semble exister. Pour "portage" son utilisation libre n'a pas l'air d'être interdit non plus puisque l'abre officiel contient déjà des logiciels comme portage-mod_jabber ou portagemaster qui n'ont pas l'air d'être relié au projet Gentoo.

----------

## Magic Banana

Voici venu le temps des rires et des chants ! offline-emerge-0.4.1 est là. Vous pouvez le considérer comme offline-emerge-0.4 avec en plus :

1) Une man page ! (c'est fou ce que ça prend du temps de rédiger cette petite chose là !)

2) Une ligne d'affichage pour faire patienter l'utilisateur une fois la commande appelée.

3) Deux changements de vocabulaires : "amovible device" est désormais "removable-device" et le répertoire "urls" s'appelle maintenant "actions".

4) Un ebuild mieux foutu (le warning concernant la variable MOVING à définir est maintenant affiché après l'installation et uniquement si nécessaire).

L'ebuild devrait être téléchargeable ici si Temet veut.

Placez le dans votre overlay et "emerge offline-emerge" !  :Wink:   (cf. la documentation de Portage sur les overlays).

----------

## Temet

C'est fait.

'ttention, seule la dernière version est dispo sur le ftp  :Wink: 

----------

## Magic Banana

Après une attente insoutenable de plusieurs semaines arrive enfin une nouvelle version de offline-emerge... Bon, en fait, cela fait déjà pas mal de temps que je l'ai finie mais entre le foi gras et un déménagement italien organisé depuis la France (je me suis fait viré par le propriétaire  :Confused:  ), je n'ai pas pris le temps de vous en faire part plus tôt.

Visiblement personne d'autre que moi n'a vraiment testé mon script jusque là étant donné les nombreux bugs qui étaient encore présents (mais muets la plupart du temps avec mon utilisation de offline-emerge) ! La version précédente ne fonctionnait pas avec plusieurs mirroirs dans GENTOO_MIRRORS, avec l'option --oldactions il y avait un problème lors de l'installation d'un logiciel consécutivement à un autre où la catégorie était précisée, suite à l'installation d'un nouvel arbre Portage le script cherchait à installer un logiciel nommé suivant le dernier fichier du répertoire courrant dans l'ordre alphabétique (oui c'est bizzare et mais c'est plus bash qui est bizzare que mon script : je change maintenant les options de base du bash au début des script !), la gestion d'une clé USB (ou autre) pleine était cassée, enfin il est maintenant possible d'utiliser ofline-emerge sur un système où l'arbre Portage n'est plus dans un répertoire nommé "portage" (faut être tordu quand même !).

La nouvelle version (0.4.2) corrige tout cela. Je ne pense pas apporter de nouvelles fonctionalités à offline-emerge mais si vous trouvez des bogues, je me pencherai dessus. Comme d'habitude, je transmets à Temet les sources ainsi que l'ebuild. Il vous suffit donc de télécharger l'ebuild, de le placer dans votre overlay (cf. la documentation de Portage sur les overlays) et d'exécuter :

```
# emerge offline-emerge
```

Si vous êtes déjà sans connexion Internet, n'oubliez pas auparavant de télécharger les sources à la main et de placer l'archive ainsi récupérée parmi vos distfiles.

EDIT : Juste pour être un peu plus complet dans mon Changelog, j'ai aussi corrigé et amélioré la man page notamment en ajoutant une section expliquant comment faire "la première fois". Bah oui, c'est toujours plus difficile la première fois. Rapelez-vous...

----------

## Temet

Fait.

Bonne Année aussi à toi ;)

 *Magic Banana wrote:*   

> Bah oui, c'est toujours plus difficile la première fois. Rapelez-vous...

 

:x ... la pauvre :/

----------

## Magic Banana

Mon séjour en Italie touche à sa fin... mais arrivé en France dans un nouvel appartement je risque de devoir encore souffrir de l'absence d'Internet.  :Crying or Very sad: 

Quoi qu'il en soit voici une nouvelle version d'offline-emerge (0.4.3). Pas grand chose de nouveau à part une nouvelle ligne expliquant à l'utilisateur ce que fait le script (lors de la suppression de l'ancien arbre Portage) et la correction d'un bug qui faisait tourner en rond fetch si la place venait à manquer lors du téléchargement d'un instantanné de l'arbre Portage.

La grande nouveauté en revanche est la création d'un fil dans le sous-forum tentant d'expliquer du mieux que j'ai pu, l'installation/utilisation d'offline-emerge, ses avantages, etc.

Allez donc y faire un tour !  :Wink: 

----------

## Temet

Online

----------

