Annexe A Exemples de scripts de finalisation personnalisés

Les scripts de finalisation personnalisés suivants vous permettent d'exécuter des tâches particulières.

Remarque –

Vous devrez modifier le fichier manifest afin de désigner les nouveaux scripts personnalisés. Reportez-vous aux instructions de la section Utilisation de scripts personnalisés.

Exemple de script permettant d'ajouter des packages à une image

Lors de l'assemblage d'une image, vous pouvez faire des essais de fonctionnement de l'image lorsque des packages sont ajoutés ou supprimés d'un jeu de travail. Ce type de tests est pris en charge par le constructeur de distribution. Des packages supplémentaires peuvent être ajoutés à la liste existante dans la section package d'un fichier manifest. Les packages à supprimer peuvent être ajoutés à la section post_install_remove_package. Après avoir apporté des modifications au fichier manifest pour ajouter ou supprimer des packages, vous devez relancer le processus de création depuis le début et télécharger de nouveau l'ensemble des packages. Cette opération peut prendre du temps. Vous pouvez effectuer ces modifications plus rapidement en utilisant les scripts de finalisation.

Les scripts personnalisés suivants ajoutent un package IPS à l'image à partir d'un autre référentiel spécifié dans le fichier manifest. Le package est ajouté à la zone d'image du package. Le nom du package à ajouter est inclus dans le script. Cet exemple montre également comment utiliser le programme ManifestRead pour obtenir des valeurs à partir du fichier manifest.

Exemple A–1 Exemple de script pour l'ajout de packages

#!/bin/ksh
#
#
# Name:
# add_my_pkg
#
# Description:
# This script will add the package SUNWcdrw from
# the alternate repository specified in the manifest
# at pkg_repo_addl_authority.
# 
# Args:
#
#   5 arguments are passed in by default from the DC.
#
#   MFEST_SOCKET: Socket needed to get manifest data via ManifestRead object
#   PKG_IMG_PATH: Package image area
#   TMP_DIR: Temporary directory 
#   BR_BUILD: Area where boot archive is put together (not used in this example)
#   MEDIA_DIR: Area where the media is put (not used)
#
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

if [ "$#" != "5" ] ; then
        print -u2 "Usage: $0: Requires 5 args:"
        print -u2 "    Reader socket, pkg_image area, tmp dir,"

        print -u2 "    boot archive build area, media area"
        exit 1
fi

MFEST_SOCKET=$1

PKG_IMG_PATH=$2
if [ ! -d $PKG_IMG_PATH ] ; then
        print -u2 "$0: Image package area $PKG_IMG_PATH is not valid"
        exit 1
fi

PKGCMD="/bin/pkg"

#Install this package 
TEST_PKGS="SUNWcdrw"

#
# You would have specified the additional repository like this in the manifest
#
#                 
#   <pkg_repo_addl_authority>
#        <main url="http://localhost:10000" authname="localtest"/>
#   </pkg_repo_addl_authority>

# Get the alternate repository URL from the manifest
add_url=/usr/bin/ManifestRead ${MFEST_SOCKET} \
"img_params/pkg_repo_addl_authority/main/url"

# Get the alternate repository authority from the manifest
add_auth=/usr/bin/ManifestRead ${MFEST_SOCKET} \
"img_params/pkg_repo_addl_authority/main/authname"

added_authority=0

#
# Check if authority is already set in the package image area
# if not, add it in
#
${PKGCMD} -R $PKG_IMG_PATH authority $add_auth > /dev/null 2>& 1
if [ $? != 0 ] ; then
        ${PKGCMD} -R $PKG_IMG_PATH  set-authority -O ${add_url} ${add_auth}
        added_authority=1
fi

if [ $? != "0" ] ; then
        print -u2 "$0: Unable to set additional authority"
        exit 1
fi

for t in ${TEST_PKGS} ; do
        pkg_name="pkg://${add_auth}/${t}"
        ${PKGCMD} -R $PKG_IMG_PATH install ${pkg_name}
        if [ $? != "0" ] ; then
                print -u2 "$0: Unable to install ${pkg_name}"

                exit 1
        fi
done

# if we have added the additional authority, unset it so it doesn't pollute what's
# originally there
if [ $added_authority == 1 ] ; then
         ${PKGCMD} -R $PKG_IMG_PATH  unset-authority ${add_auth}
fi

exit 0

Utilisation de scripts personnalisés

Une fois que vous avez préparé votre script personnalisé, vous devez ajouter une référence au script dans le fichier manifest. Vous êtes ensuite prêt à utiliser le script lors de la création de l'image.

Ajout d'un script à un fichier manifest

Vous devez mettre à jour le fichier manifest pour qu'il désigne les scripts personnalisés que vous souhaitez utiliser. Par exemple, si vous avez créé un script, /export/home/user1/test_my_pkg, pour tester votre package personnalisé, vous devez référencer le script comme suit dans la section de finalisation du fichier manifest. Le point de contrôle my_test indique où la création va redémarrer.

<finalizer>
      <script name="/export/home/user1/test_my_pkg">
           <checkpoint name="my_test" message="Running my test package"/>
      </script>
      <script name="/usr/share/distro_const/pre_boot_archive_pkg_image_mod">
           <checkpoint name="im-mod" message="Image area modifications"/>
      </script>
      ........
</finalizer>

Le script personnalisé ci-dessus est conçu pour ajouter ou supprimer des packages de la zone d'image du package. Vous devez donc référencer ce script comme premier script de finalisation dans la section <finalizer> du fichier manifest. Incluez dans cette référence un nom de point de contrôle qui indique le point du processus de création d'image à partir duquel vous voulez relancer la création afin de tester le package ajouté.

Remarque –

L'exemple de script ci-dessus suppose qu'un autre référentiel a été spécifié dans le fichier manifest, à l'aide du champ pkg_repo_addl_authority. Le fichier manifest par défaut est indiqué lorsque le champ pkg_repo_addl_authority est mis en commentaire et, par conséquent, inutilisé. Supprimez donc la balise de commentaire de ce champ, et mettez à jour ses valeurs pour fournir une URL et un authname valides.

Par exemple, si l'autorité supplémentaire est disponible sur le localhost sur le port 10000, avec le nom localtest, vous devez modifier le champ pkg_repo_addl_authority dans le fichier manifest comme suit :

<pkg_repo_addl_authority>
<main
url="http://localhost:10000"
authname="localtest"/>
<mirror url="" />
</pkg_repo_addl_authority>

Exécution du script

Une fois que vous avez terminé d'appliquer des modifications dans le fichier manifest pour référencer votre nouveau script, vous pouvez commencer à créer votre image à partir du début. Par la suite, si vous apportez des modifications à votre package, vous n'avez plus besoin de relancer le processus depuis le début. Vous pouvez générer une image avec votre package modifié à partir du point de contrôle qui exécute votre script.

Remarque –

Cette option suppose que la zone de construction se trouve dans un système de fichiers ZFS. Sans système ZFS, vous ne pouvez pas utiliser les points de contrôle.

Vous trouverez ci-dessous la séquence de commandes qu'un utilisateur doit exécuter afin de tester plusieurs fois les modifications apportées aux packages.

Lancez la création à partir du début après avoir modifié le fichier manifest. Vous n'avez besoin d'effectuer cette étape qu'une seule fois.
distro_const build my_updated_manifest.xml

Vérifiez les étapes qui peuvent être reprises.

distro_const build -l my_updated_manifest.xml

Relancez le processus à partir de l'étape de votre modification de package. Vous pouvez redémarrer à partir de cette étape autant de fois que nécessaire au cours du débogage de votre contenu modifié.
distro_const build -r my_test my_updated_manifest.xml

Pour en savoir plus sur l'utilisation de la commande distro_const avec les options de points de contrôle, comme illustré dans l'exemple, reportez-vous à la section Création d'une image par étapes.

Exemple de script permettant de tester d'autres packages

Lorsqu'un package est spécifié dans la section package d'un fichier manifest, il est installé dans la zone d'image de package par le constructeur de distribution. Si vous disposez d'une autre version de ce package (votre copie privée d'un package, par exemple), vous pouvez la tester à l'aide d'un script de finalisation personnalisé. Le script de finalisation remplacera la version installée précédente du package par une version testée à partir d'un autre référentiel.

Dans le script personnalisé suivant, un serveur de référentiel IPS est en cours d'exécution sur http://localhost:10000. Le nom du package à remplacer est transmis sous forme d'argument. Le script désinstalle d'abord la version existante du package, puis installe la version testée à partir de l'autre référentiel. Ce script personnalisé indique également comment transmettre les arguments en tant qu'arguments de script de finalisation. Dans le script, notez les commentaires qui expliquent comment il réalise ces tâches.

Exemple A–2 Exemple de script permettant de tester des packages

#!/bin/ksh
#
#
# Name:
# test_my_pkg
#
# Description:
# This script will build an image using my test package
# from my local repository. 
#
# Args:
#
#   These Arguments are passed in by default from the DC.
#
#   MFEST_SOCKET: Socket needed to get manifest data via ManifestRead object \
# (not used in this example)
#   PKG_IMG_PATH: Package image area
#   TMP_DIR: Temporary directory
#   BR_BUILD: Area where boot archive is put together (not used in this example)
#   MEDIA_DIR: Area where the media is put (not used)
#   TEST_PKG: Package to replace with one from the test repo
#
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

if [ "$#" != "6" ] ; then
        print -u2 "Usage: $0: Requires 6 args:"

        print -u2 "    Reader socket, pkg_image area, tmp dir,"
        print -u2 "    boot archive build area, media area, pkg_name"
        exit 1
fi


PKG_IMG_PATH=$2
if [ ! -d $PKG_IMG_PATH ] ; then
        print -u2 "$0: Image package area $PKG_IMG_PATH is not valid"
        exit 1
fi

PKGCMD="/bin/pkg"

#The test packages are passed in as arguments to this finalizer script
#You would have specified the argument like this in the finalizer section
#to pass in the argument
#
#
#  <finalizer>
#       <script name="/my/update_my_pkg_test">
#               <checkpoint name="update-pkg" message= \
"Replaces an existing package with my own"/>
#                    <argslist>
#                       "SUNWcdrw"
#                    </argslist>
#        </script>
#  </finalizer>
#
TEST_PKG=$6

# Assume that my test package resides in
#a repository running on port 10000 of the localhost.

# Specify  alternate repository URL
add_url="http://localhost:10000"

# Specify alternate repository authority
add_auth="MY_TEST"
# Check if authority is already set in the package image area, if not,
# add it in

added_authority=0

${PKGCMD} -R $PKG_IMG_PATH authority $add_auth > /dev/null 2>& 1
if [ $? != 0 ] ; then
        ${PKGCMD} -R $PKG_IMG_PATH  set-authority -O ${add_url} ${add_auth}
        if [ $? != "0" ] ; then
             print -u2 "$0: Unable to set additional authority"
             exit 1
        fi
        added_authority=1
fi


if [ $? != "0" ] ; then
        print -u2 "$0: Unable to set additional authority"
        exit 1
fi

# Remove the package that's currently in the package image area.
${PKGCMD} -R $PKG_IMG_PATH uninstall ${TEST_PKG}
if [ $? != "0" ] ; then
        print -u2 "$0: Unable to uninstall ${TEST_PKG}"
        exit 1
fi

# Install the package from test repo
pkg_name="pkg://${add_auth}/${TEST_PKG}"

${PKGCMD} -R $PKG_IMG_PATH install ${pkg_name}
if [ $? != "0" ] ; then
        print -u2 "$0: Unable to install ${pkg_name}"
        exit 1
fi

# if we have added the additional authority, unset it so it doesn't pollute what's
# originally there
if [ $added_authority == 1 ] ; then
         ${PKGCMD} -R $PKG_IMG_PATH  unset-authority ${add_auth}
fi

exit 0

Exemple de script permettant d'ajouter un package SVR4 à une image

Si vous disposez d'un package au format SVR4, vous pouvez le tester dans une image avant de procéder à sa conversion en package IPS. Vous pouvez utiliser un script de finalisation pour ajouter le contenu d'un package SVR4 à l'image. Reportez-vous au script personnalisé suivant et notez les commentaires dans le script expliquant la manière dont le script réalise cette tâche.

Remarque –

Vous devrez modifier ce script pour inclure le chemin de votre package SVR4. Reportez-vous aux commentaires dans le script.

Exemple A–3 Exemple de script permettant l'ajout de packages SVR4

#!/bin/ksh
#
#
# Name:
# add_my_svr4_pkg
#
# Description:
# This script will build an image using an SVR4 package
# located at a user specified file path.
#
# Note:
# The user must modify this script and provide a valid
# path to an SVR4 package in the PKG_PATH variable.
#
# #
# Args:
#
#   5 arguments are passed in by default from the DC.
#
#   MFEST_SOCKET: Socket needed to get manifest data via ManifestRead object (not used)
#   PKG_IMG_PATH: Package image area
#   TMP_DIR: Temporary directory
#   BR_BUILD: Area where boot archive is put together (not used in this example)
#   MEDIA_DIR: Area where the media is put (not used)
#
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

if [ "$#" != "5" ] ; then
        print -u2 "Usage: $0: Requires 5 args:"

        print -u2 "    Reader socket, pkg_image area, tmp dir,"
        print -u2 "    boot archive build area, media area"
        exit 1
fi

PKG_IMG_PATH=$2
if [ ! -d $PKG_IMG_PATH ] ; then
        print -u2 "$0: Image package area $PKG_IMG_PATH is not valid"
        exit 1
fi

TMP_DIR=$3

#
# Install an SVR4 packages into the package image area
#

#create an admin file for non-interactive pkgadd's

ADMIN_FILE=${TMP_DIR}/admin.$$
cat << \ADMIN_EOF > $ADMIN_FILE
mail=
instance=unique
partial=nocheck
runlevel=nocheck
idepend=nocheck
rdepend=nocheck
space=nocheck
setuid=nocheck
conflict=nocheck
action=nocheck
networktimeout=60
networkretries=3
authentication=quit
keystore=/var/sadm/security
proxy=
basedir=default
ADMIN_EOF

#
# Path to your new packages
#
PKG_PATH=<User-specified path for SVR4 package>

#
# Test package name 
#
SVR4_TEST_PKG=SUNWmy-test

/usr/sbin/pkgadd -n -a ${ADMIN_FILE} -d $PKG_PATH -R ${PKG_IMG_PATH} ${SVR4_TEST_PKG}

if [ $? != "0" ] ; then
        echo "installing package failed"

        exit 1
fi

/bin/rm ${ADMIN_FILE}

exit 0

Previous: Chapitre 3 x86 : conception et création d'une machine virtuelle