Ci-dessous, le su-per-be script que j'ai développé pour faire un export $U !
Pour l'import, c'est [[Import Ordonnancement $U|dollaru_import_v1.07.ksh]]

== {{ExtractCode|dollaru_export_v1.07.ksh}} ==
<code language=bash>
#!/bin/ksh
#------------------------------------------------------------------------------------
# TITRE                : dollaru_export.ksh
# AUTEUR               : MGE
# DATE                 : 02/10/2008
# PROJET               : Migration Recette --> Exploit
# DESCRIPTION          : Export $U paramétrable
# PARAMETRES           : voir fonction "show_usage".
#------------------------------------------------------------------------------------
# DERNIERE MAJ         : V1.07 18/11/2008
# AUTEUR               :
# DESCRIPTION     1.03 : Remplacement de -env par "-vd" ou "-variableDir"
#                 1.03 : Ajout de "-model"
#                 1.03 : Ajout du type de tâche et de l'utilisateur au nom de l'export de la tache
#                 1.04 : Permettre la maj du model avant export en model (-updateModel)
#                 1.05 : Recherche automatique du dossier $U (pas de maj VERSION; compatible version précédente)
#                 1.06 : Ajout de "-extSes" ou "-extendFromSession"
#                 1.07 : Correction du cas "$Rul"==""
#------------------------------------------------------------------------------------
commandName=`basename $0`

#------------------------------------------------------------------------------------
# Fonction show_usage
#------------------------------------------------------------------------------------
show_usage()
{
  [ "${1}" = "valid" ] || echo "Invalid Parameter : $@"
  
  echo "usage : $commandName \033[1m-output\033[0m the_dest [\033[1moptions\033[0m] \033[1mobjects\033[0m [\033[1m-h\033[0m]"
  echo
  echo "  \033[1m-output\033[0m the_dest   : the_dest peut être un répertoire ou une archive (.tar ou .tar.gz)"
  echo "  \033[1moptions\033[0m :"
  echo "    \033[1m-variableDir\033[0m dir : partie du chemin, dans les ressources, à rendre variable (doit correspondre au nom complet d'un sous-répertoire, entre //)"
  echo "    \033[1m-vd\033[0m dir          : idem -variableDir the_dir"
  echo "    \033[1m-extendFromSession\033[0m : ajoute à la liste des choses à exporter toutes les uprocs, ressources et tâches dont dépendent les sessions à exporter"
  echo "    \033[1m-extSes\033[0m            : idem -extendFromSession"
  echo "    \033[1m-model\033[0m             : exporte les tâches "Modèle" (sinon, exporte les non-modèle)"
  echo "    \033[1m-updateModel\033[0m       : met à jour les tâches Modèle avec la non-modèle, implique -model"
  echo "  \033[1mobjects\033[0m (tous supportent les caractères génériques, par exemple \"APP_*\") :"
  echo "    \033[1m-uproc\033[0m \"a b c\"   : liste des Uprocs à exporter"
  echo "    \033[1m-session\033[0m \"a b c\" : liste des sessions à exporter"
  echo "    \033[1m-task\033[0m \"a b c\"    : liste des tâches à exporter"
  echo "    \033[1m-ress\033[0m \"a b c\"    : liste des ressources à exporter"
  echo "    \033[1m-any\033[0m \"a b c\"     : ajoute cette liste à celles des Uprocs, sessions, taches, and ressources à exporter"
  echo "  \033[1m-h\033[0m                 : affiche cette aide"
  echo
  echo "exemple : $commandName -output "'/tmp/dollaru_export_APP-$(date +"%y%m%d-%H%M%S").tar.gz'" -vd REC -any \"APP_*\""

  exit 127
}
#------------------------------------------------------------------------------------
# Declarations des variables
#------------------------------------------------------------------------------------
set -A aUprocList
set -A aSessionList
set -A aTaskList
set -A aRessList
taskType=NOMODEL
taskEType=NOMODEL
typeset -l updateModel=false
typeset -l extendFromSession=false

#------------------------------------------------------------------------------------
# Lecture du paramètre
#------------------------------------------------------------------------------------

while [ $# -gt 0 ]; do
  typeset -l param="$1"
  case "$param" in
    -output) FinalExportName=$2;
      [[ "$2" = "" ]] && show_usage -output;
      shift;;
    -variabledir|-vd) CurrentEnvPath=$2;
      [[ "$2" = "" ]] && show_usage -variableDir;
      shift;;
    -uproc) set -A aUprocList ${aUprocList[@]} $2;
      [[ "$2" = "" ]] && show_usage;
      shift;;
    -session) set -A aSessionList ${aSessionList[@]} $2;
      [[ "$2" = "" ]] && show_usage;
      shift;;
    -task) set -A aTaskList ${aTaskList[@]} $2;
      [[ "$2" = "" ]] && show_usage;
      shift;;
    -ress) set -A aRessList ${aRessList[@]} $2;
      [[ "$2" = "" ]] && show_usage;
      shift;;
    -any) set -A aUprocList ${aUprocList[@]} $2;
      set -A aSessionList ${aSessionList[@]} $2;
      set -A aTaskList ${aTaskList[@]} $2;
      set -A aRessList ${aRessList[@]} $2;
      [[ "$2" = "" ]] && show_usage;
      shift;;
    -model) taskType=MODEL; taskEType=MODEL;;
    -updatemodel) updateModel=true; taskType=NOMODEL; taskEType=MODEL;;
    -extendfromsession|-extses) extendFromSession=true;;
    -h) show_usage valid;;
    *)
       show_usage $@;;
  esac
  shift;
done

[[ "$FinalExportName" = "" ]] && show_usage;
#[[ "$CurrentEnvPath" = "" ]] && show_usage;

#------------------------------------------------------------------------------------
# Chargement de l'environnement $U
#------------------------------------------------------------------------------------
UXMGRDIR=`find / -name "uxsetenv" -exec dirname {} \; 2>/dev/null`
echo "Répertoires mgr \$U trouvés :"
echo "$UXMGRDIR"
while [ `echo "$UXMGRDIR" | wc -w` -ne 1 ]; do
  printf "Spécifiez le répertoire mgr \$U : ";
  read UXMGRDIR
done

cd $UXMGRDIR
. ./uxsetenv
cd - >/dev/null


#------------------------------------------------------------------------------------
# traitement de l'ExportName
#------------------------------------------------------------------------------------
case $FinalExportName in
    *.tar.gz) ExportDir=$(dirname $FinalExportName)/$(basename $FinalExportName .tar.gz);;
    *.tar) ExportDir=$(dirname $FinalExportName)/$(basename $FinalExportName .tar);;
    *) ExportDir=$(dirname $FinalExportName)/$(basename $FinalExportName);;
esac

[[ "$ExportDir" = "" ]] && show_usage;

#------------------------------------------------------------------------------------
# traitement de l'EnvPath
#------------------------------------------------------------------------------------
ExportedEnvPath=E$(echo $CurrentEnvPath | cut -b 2- | tr -c '[:cntrl:]' '[$*]')
[[ "$CurrentEnvPath" = "" ]] && ExportedEnvPath=

typeset -i EnvPathSize=`echo $ExportedEnvPath | wc -c`
[[ `echo $CurrentEnvPath | wc -c` -ne $EnvPathSize ]] && echo "\$CurrentEnvPath doit faire la même taille que $ExportedEnvPath" && exit 127


#------------------------------------------------------------------------------------
# Declarations et validations des variables internes
#------------------------------------------------------------------------------------

Dir_Res=${ExportDir}/res
Dir_Upr=${ExportDir}/upr
Dir_Rul=${ExportDir}/rul
Dir_Ses=${ExportDir}/ses
Dir_Tsk=${ExportDir}/tsk
Dir_Tmp=${ExportDir}/tmp

Lst_Res=${Dir_Tmp}/list-res-$(date +"%y%m%d-%H%M").txt
Lst_Upr=${Dir_Tmp}/list-upr-$(date +"%y%m%d-%H%M").txt
Lst_Rul=${Dir_Tmp}/list-rul-$(date +"%y%m%d-%H%M").txt
Lst_Ses=${Dir_Tmp}/list-ses-$(date +"%y%m%d-%H%M").txt
Lst_Tsk=${Dir_Tmp}/list-tsk-$(date +"%y%m%d-%H%M").txt

FullExport=${ExportDir}.tar

Log=$(dirname $0)/$(basename $ExportDir).log

#------------------------------------------------------------------------------------
# Création du répertoire d'extraction
#------------------------------------------------------------------------------------

#Création et nettoyage des repertoires destination
rm -rf $ExportDir
rm -f $FinalExportName
mkdir -p $Dir_Res $Dir_Upr $Dir_Rul $Dir_Ses $Dir_Tsk $Dir_Tmp

#------------------------------------------------------------------------------------
# Fonction de test des erreurs
#------------------------------------------------------------------------------------
Test_Erreur()
{
  if [ ${1} -eq 0 ]
        then
		cat ${Log}.err >> ${Log} 2>/dev/null
		rm -f ${Log}.err
                echo "# Traitement ${2} OK" | tee -a ${Log}
                echo "#" >> ${Log}
        else
  		cat ${Log}.err 2>/dev/null | tee -a ${Log}
		rm -f ${Log}.err
                echo "#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#" | tee -a ${Log}
                echo "#" | tee -a ${Log}
                echo "#" | tee -a ${Log}
                echo "#" | tee -a ${Log}
                echo "# Erreur lors du traitement ${2} : ${1}" | tee -a ${Log}
                echo "#" | tee -a ${Log}
                echo "#" | tee -a ${Log}
                echo "#" | tee -a ${Log}
                echo "#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#" | tee -a ${Log}
                exit 1
  fi
}

echo "#--------------------------------------------------------------------------" | tee -a ${Log}
echo "#                                                                         -" | tee -a ${Log}
echo "#                                                                         -" | tee -a ${Log}
echo "#                           Script d'exportation                          -" | tee -a ${Log}
echo "#                                                                         -" | tee -a ${Log}
echo "# Export total des Sessions Uprocs Taches du plan Batch de recette        -" | tee -a ${Log}
echo "#                                                                         -" | tee -a ${Log}
echo "#                                                                         -" | tee -a ${Log}
echo "#                                                                         -" | tee -a ${Log}
echo "#- Debut ------------------------------------------------------------------" | tee -a ${Log}

#
# Generation des listes definitives des objets a exporter
#

printf > $Lst_Res; printf > $Lst_Upr; printf > $Lst_Ses; printf > $Lst_Tsk; printf > $Lst_Rul

for Prefixe in ${aSessionList[@]}; do
  $UXEXE/uxlst SES SES=${Prefixe} | tail +5 | awk '{ print $1 }' >> $Lst_Ses
done

#
# Ajouts extendFromSession
#

if [[ $extendFromSession == true ]]; then
  cat $Lst_Ses | while read session; do
    set -A aTaskList ${aTaskList[@]} ${session}
    $UXEXE/uxshw ses exp SES=$session | grep "| upr  :" | cut -d \: -f 2 | while read uproc; do
      set -A aUprocList ${aUprocList[@]} ${uproc}
      $UXEXE/uxshw upr exp UPR=$uproc | grep "res          :" | cut -d \: -f 2 | while read res; do
        set -A aRessList ${aRessList[@]} ${res}
      done
    done
  done
fi


for Prefixe in ${aRessList[@]}; do
  $UXEXE/uxlst RES RES=${Prefixe} | tail +5 | awk '{ print $1 }' >> $Lst_Res
done

for Prefixe in ${aUprocList[@]}; do
  $UXEXE/uxlst UPR UPR=${Prefixe} | tail +5 | awk '{ print $1 }' >> $Lst_Upr
done

for Prefixe in ${aTaskList[@]}; do
  $UXEXE/uxlst TSK UPR=${Prefixe} $taskType | tail +5 | sed "s/^               / _          _  /" | awk '{ print $1" "$3 }' >> $Lst_Tsk
  $UXEXE/uxshw tsk exp UPR=${Prefixe} mu=* $taskType vupr=* ses=* partage | grep "rule" | cut -b 27-34 | sort | uniq >> $Lst_Rul
  $UXEXE/uxlst TSK SES=${Prefixe} UPR=* $taskType | tail +5 | sed "s/^               / _          _  /" | awk '{ print $1" "$3 }' >> $Lst_Tsk
  $UXEXE/uxshw tsk exp SES=${Prefixe} UPR=* mu=* $taskType vupr=* ses=* partage | grep "rule" | cut -b 27-34 | sort | uniq >> $Lst_Rul
done


#
# Suppression des doublons
#

sort $Lst_Ses | uniq > $Lst_Ses.tmp && mv $Lst_Ses.tmp $Lst_Ses
sort $Lst_Res | uniq > $Lst_Res.tmp && mv $Lst_Res.tmp $Lst_Res
sort $Lst_Upr | uniq > $Lst_Upr.tmp && mv $Lst_Upr.tmp $Lst_Upr
sort $Lst_Tsk | uniq > $Lst_Tsk.tmp && mv $Lst_Tsk.tmp $Lst_Tsk
sort $Lst_Rul | uniq > $Lst_Rul.tmp && mv $Lst_Rul.tmp $Lst_Rul


#
# Export des objets
#

echo $ExportedEnvPath > ${Dir_Res}/exportedpath.txt

while read Res; do
  $UXEXE/uxext RES EXP RES=$Res output=${Dir_Tmp}/$Res.exp.tmp > ${Log}.err 2>&1
  Test_Erreur $? "Extraction de la ressource $Res"
  cat ${Dir_Tmp}/$Res.exp.tmp | sed "s/\/$CurrentEnvPath\//\/$ExportedEnvPath\//" > ${Dir_Res}/$Res.exp 2>> ${Log}
  Test_Erreur $? "Variabilisation de la ressource $Res"
done < $Lst_Res

while read Upr; do
  $UXEXE/uxext UPR EXP UPR=$Upr output=${Dir_Upr}/$Upr.exp > ${Log}.err 2>&1
  Test_Erreur $? "Extraction de l'Uproc $Upr"
done < $Lst_Upr

while read Rul; do
  if [[ "$Rul" != "" ]]; then
    $UXEXE/uxext RUL EXP RUL=$Rul output=${Dir_Rul}/$Rul.exp > ${Log}.err 2>&1
    Test_Erreur $? "Extraction de la regle $Rul"
  fi
done < $Lst_Rul

while read Ses; do
  $UXEXE/uxext SES EXP SES=$Ses output=${Dir_Ses}/$Ses.exp > ${Log}.err 2>&1
  Test_Erreur $? "Extraction de la session $Ses"
done < $Lst_Ses

while read Tsk; do
  Ses=`echo $Tsk | awk '{ print $1 }'`
  Upr=`echo $Tsk | awk '{ print $2 }'`
  SesFile="$Ses"
  SesTsk="SES=${Ses}"
  [[ "$Ses" = "_" ]] && SesFile="none" && Ses=" " && SesTsk=""
    
  [[ $updateModel == true ]] &&
  {
    tskVer=`$UXEXE/uxshw tsk exp SES=\"$Ses\" UPR=$Upr mu=* $taskType vupr=* partage | grep "| vupr" | head -n 1 | cut -d \: -f 2 | cut -d \  -f 2`
    $UXEXE/uxdup TSK EXP SES=\"$Ses\" UPR=$Upr MU=* VUPR=$tskVer $taskType TSES=\"$Ses\" TUPR=$Upr TVUPR=$tskVer TMU=\" \" T$taskEType > ${Log}.err 2>&1
    Test_Erreur $? "Mise à jour de la tache MODEL $Tsk"
  }
  
  tskUser=`$UXEXE/uxshw tsk exp SES=\"$Ses\" UPR=$Upr mu=* $taskEType vupr=* partage | grep "| user" | head -n 1 | cut -d \: -f 2 | cut -d \  -f 2`
  $UXEXE/uxext TSK EXP $SesTsk UPR=$Upr $taskEType output=${Dir_Tsk}/${SesFile}-${Upr}-${taskEType}-${tskUser}.exp > ${Log}.err 2>&1
  
  Test_Erreur $? "Extraction de la tache $taskEType $Tsk"
done < $Lst_Tsk

echo $VERSION > ${ExportDir}/version.txt
rm $Dir_Tmp/*

#------------------------------------------------------------------------------------
# traitement de l'ExportName pour eventuels tar & compression
#------------------------------------------------------------------------------------
case $FinalExportName in
    *.tar.gz) tar cf $ExportDir.tar -C `dirname $ExportDir` `basename $ExportDir`
              Test_Erreur $? "Creation de l'archive $ExportDir.tar"
              gzip $ExportDir.tar
              Test_Erreur $? "Compression de l'archive $ExportDir.tar.gz"
              rm -rf $ExportDir $ExportDir.tar;;
    *.tar) tar cf $ExportDir.tar -C `dirname $ExportDir` `basename $ExportDir`
           Test_Erreur $? "Creation de l'archive $ExportDir.tar"
           rm -rf $ExportDir;;
esac

echo "#- Fin ------------------------------------------------------------------" | tee -a ${Log}

</code>