Création d'un fichier prototype

Le fichier prototype est un fichier ASCII qui sert à spécifier des informations sur les objets d'un package. Chaque entrée du fichier prototype décrit un seul objet, tel un fichier de données, un répertoire, un fichier source ou un objet exécutable. Les entrées du fichier prototype se compose de plusieurs champs d'information séparés par des espaces. Notez que ces champs doivent apparaître dans un ordre spécifique. Les lignes de commentaires commencent par une dièse (#) et sont ignorés.

Vous pouvez créer un fichier prototype dans un éditeur de texte ou à l'aide de la commande pkgproto. Lorsque vous créez ce fichier pour la première fois, l'utilisation de la commande pkgproto est recommandée car elle permet de créer le fichier d'après la hiérarchie des répertoires créée précédemment. Si vous n'avez pas organisé vos fichiers comme il l'est suggéré à la rubrique Organisation du contenu d'un package, il vous faut créer le fichier prototype de zéro dans un éditeur de texte, tâche qui s'avère bien plus longue.

Format du fichier prototype

Format de chaque ligne du fichier prototype :

partftypeclasspathmajorminormodeownergroup

Seuls les champs ftype, class, path, mode, owner et group sont habituellement définis. Ces champs sont décrits dans les sections suivantes. Reportez-vous à la page de manuel prototype(4) pour plus d'informations sur ces champs.

Champ ftype

Le champ ftype (type de fichier) est un champ à un caractère qui indique le type de fichier de l'objet du package. Les types de fichier valides sont décrits dans le tableau suivant :

Champ class

Le champ class nomme la classe à laquelle un objet appartient. L'utilisation des classes est une fonction de conception de package facultative. Cette fonction est traitée en détail à la la rubrique Rédaction de scripts d'action de classe.

Lorsque vous n'utilisez pas de classes, les objets appartiennent à la classe none. Lorsque vous exécutez la commande pkgmk pour créer votre package, la commande insère le paramètre CLASSES=none dans le fichier pkginfo. Les fichiers dont le type est i doivent contenir un champ class vide.

Champ path

Le champ path sert à définir le répertoire dans lequel l'objet du package réside sur le système cible. Vous pouvez indiquer l'emplacement à l'aide d'un nom de chemin absolu (par exemple, /usr/bin/mail) ou d'un nom de chemin relatif (par exemple, bin/mail). L'utilisation d'un nom de chemin absolu signifie que l'emplacement de l'objet sur le système cible est défini par le package et ne peut être modifié. Un objet de package dont le nom de chemin est relatif est réadressable.

Un objet réadressable n'a pas besoin d'un chemin absolu sur le système cible. Son emplacement est en fait déterminé au cours de la procédure d'installation.

Vous pouvez définir certains, voire l'ensemble des objets d'un package comme étant des objets réadressables. Avant de rédiger des scripts d'installation ou de créer le fichier prototype, décidez si les objets du package doivent avoir un emplacement fixe (tels les scripts de démarrage dans /etc) ou s'ils doivent être réadressables.

Il existe deux types d'objet réadressable, ceux qui sont réadressables collectivement et ceux qui sont réadressables individuellement.

Objets réadressables collectivement

Les objets réadressables collectivement sont situés relativement à une base d'installation commune appelée le répertoire de base. Un répertoire de base est défini dans le fichier pkginfo à l'aide du paramètre BASEDIR. Par exemple, un objet réadressable figurant dans le fichier prototype appelé tests/generic nécessite que le fichier pkginfo définisse le paramètre BASEDIR par défaut. Exemple :

BASEDIR=/opt

Cet exemple signifie que lors de son installation, l'objet est placé dans le répertoire /opt/tests/generic.

Le répertoire /opt est le seul répertoire dans lequel tout logiciel n'appartenant pas aux logiciels Solaris de base peut être installé.

Servez-vous autant que possible d'objets réadressables collectivement. De manière générale, la majeure partie d'un package peut être réadressable à l'aide de quelques fichiers (notamment les fichiers placés dans /etc ou /var) définis comme absolus. Toutefois, si un package contient divers emplacements de réadressage, envisagez la séparation du package en plusieurs packages employant des valeurs BASEDIR distinctes dans leurs fichiers pkginfo.

Objets réadressables individuellement

Les objets réadressables individuellement ne sont pas limités au même répertoire que les objets réadressables collectivement. Pour définir un objet réadressable individuellement, vous devez spécifier une variable d'installation dans le champ path du fichier prototype. Une fois la variable d'installation spécifiée, créez un script request pour demander au programme d'installation le répertoire de base réadressable, ou un script checkinstall pour déterminer le nom du chemin à partir des données du système de fichiers. Pour plus d'informations sur les scripts request, reportez-vous à Rédaction d'un script request, et sur les scripts checkinstall, à Procédure de recueil de données d'un système de fichiers.

Les objets réadressables individuellement sont difficiles à gérer. L'utilisation d'objets réadressables individuellement conduit parfois à la dispersion des composants de package qu'il est alors difficile d'isoler lors de l'installation de plusieurs versions ou architectures du même package. Servez-vous autant que possible d'objets réadressables collectivement.

Noms de chemin paramétriques

Un nom de chemin paramétrique est un nom de chemin qui inclut une spécification de variable. Par exemple, /opt/$PKGINST/nomdefichier est un nom de chemin paramétrique en raison de la spécification de la variable $PKGINST. La valeur par défaut d'une spécification de variable doit être définie dans le fichier pkginfo. La valeur peut ensuite être modifiée par un script request ou un script checkinstall.

La spécification de variable d'un chemin doit se trouver au début ou à la fin du chemin, ou être liée par des barres obliques (/). Un nom de chemin paramétrique valide utilise le format suivant :

$PARAM/tests
tests/$PARAM/generic
/tests/$PARAM

La spécification de variable, une fois définie, peut conduire le chemin à être évalué en tant que chemin absolu ou réadressable. Dans l'exemple ci-après, le fichier prototype contient l'entrée suivante :

f none $DIRLOC/tests/generic

Le fichier pkginfo contient l'entrée suivante :

DIRLOC=/myopt

Le nom de chemin $DIRLOC/tests/generic est évalué comme étant le nom de chemin absolu /myopt/tests/generic, indépendamment de la définition (ou de l'absence de définition) du paramètre BASEDIR dans le fichier pkginfo.

Dans cet exemple, le fichier prototype est identique à celui de l'exemple précédent et le fichier pkginfo contient les entrées suivantes :

DIRLOC=firstcut
BASEDIR=/opt

Le nom de chemin $DIRLOC/tests/generic est évalué comme étant le nom de chemin réadressable /opt/firstcut/tests/generic.

Pour plus d'informations sur les noms de chemin paramétriques, reportez-vous à Utilisation des répertoires de base paramétriques.

Remarques sur les emplacements source et de destination des objets

Le champ path du fichier prototype définit l'emplacement de l'objet sur le système cible. Spécifiez l'emplacement actuel des objets du package dans le fichier prototype si la structure de leurs répertoires ne reproduit pas celle souhaitée sur le système cible. Reportez-vous à Organisation du contenu d'un package pour plus d'informations sur l'organisation des objets d'un package.

Si votre zone de développement n'est pas organisée de la façon souhaitée pour votre package, vous pouvez utiliser le format chemin1=chemin2 dans le champ path. Dans ce format, chemin1 correspond à l'emplacement souhaité pour l'objet sur le système cible et chemin2, à l'emplacement de l'objet sur votre système.

Vous pouvez aussi utiliser le format de nom de chemin chemin1=chemin2, avec chemin1 comme nom d'objet réadressable et chemin2 comme nom de chemin complet d'accès à l'objet en question sur votre système.

chemin1 ne peut pas contenir des variables de création non définies mais peut contenir des variables d'installation non définies. chemin2 ne peut pas contenir des variables non définies bien qu'il soit possible d'utiliser des variables de création ou d'installation. Pour plus d'informations sur les différences entre les variables d'installation et les variables de création, reportez-vous à Variables d'environnement d'un package.

Les liens doivent respecter le format chemin1= chemin2 car ils sont créés à l'aide de la commande pkgadd. En règle générale, la variable chemin2 d'un lien ne doit jamais être absolue ; elle doit par contre être relative à la section du répertoire de chemin1.

Une alternative à l'utilisation du format chemin1=chemin2 est l'utilisation de la commande !search. Pour plus d'informations, reportez-vous à Offre d'un chemin de recherche pour la commande pkgmk..

Champ mode

Le champ mode peut contenir un nombre octal, un point d'interrogation (?) ou une spécification de variable. Le nombre octal indique le mode de l'objet lors de son installation sur le système cible. Le point d'interrogation (?) indique que le mode reste inchangé lors de l'installation de l'objet, impliquant que l'objet du même nom existe déjà sur le système cible.

Une spécification de variable du type $mode, dans laquelle la première lettre de la variable doit être une minuscule, signifie que ce champ est défini lors de la création du package. Notez que cette variable doit être définie lors de la phase de création dans le fichier prototype ou comme option dans la commande pkgmk. Pour plus d'informations sur les différences entre les variables d'installation et les variables de création, reportez-vous à Variables d'environnement d'un package.

Les fichiers de type i (fichier d'information), l (lien physique) et s (lien symbolique) ne doivent rien indiquer dans ce champ.

Champ owner

Le champ owner peut contenir un nom d'utilisateur, un point d'interrogation (?) ou une spécification de variable. Un nom d'utilisateur peut contenir 14 caractères maximum et doit correspondre à un nom existant sur le système cible (tel bin ou root). Le point d'interrogation (?) indique que le propriétaire reste inchangé lors de l'installation de l'objet, impliquant que l'objet du même nom existe déjà sur le système cible.

Une spécification de variable peut être du type $Owner ou $owner, où la première lettre de la variable est une majuscule ou une minuscule. Si la variable commence par une minuscule, elle doit être définie lors de la création du package, dans le fichier prototype ou comme option de la commande pkgmk. Si la variable commence par une majuscule, la spécification de variable est insérée dans le fichier pkginfo comme valeur par défaut et peut être redéfinie lors de l'installation par un script request. Pour plus d'informations sur les différences entre les variables d'installation et les variables de création, reportez-vous à Variables d'environnement d'un package.

Les fichiers dont le type est i (fichier d'information) et lb (lien physique) ne doivent rien indiquer dans ce champ.

Champ group

Le champ group peut contenir un nom d'utilisateur, un point d'interrogation (?) ou une spécification de variable. Un nom de groupe peut contenir 14 caractères maximum et doit correspondre à un nom existant sur le système cible (tel bin ou sys). Le point d'interrogation (?) indique que le groupe reste inchangé lors de l'installation de l'objet, impliquant que l'objet du même nom existe déjà sur le système cible.

Une spécification de variable peut être du type $Group ou $group, où la première lettre de la variable est une majuscule ou une minuscule. Si la variable commence par une minuscule, elle doit être définie lors de la création du package, dans le fichier prototype ou comme option de la commande pkgmk. Si la variable commence par une majuscule, la spécification de variable est insérée dans le fichier pkginfo comme valeur par défaut et peut être redéfinie lors de l'installation par un script request. Pour plus d'informations sur les différences entre les variables d'installation et les variables de création, reportez-vous à Variables d'environnement d'un package.

Les fichiers dont le type est i (fichier d'information) et l (lien physique) ne doivent rien indiquer dans ce champ.

Création d'un fichier prototype de zéro

Vous pouvez vous servir d'un éditeur de texte pour créer un fichier prototype de zéro, en ajoutant une entrée par objet de package. Reportez-vous à Format du fichier prototype et à la page de manuel prototype(4) pour plus d'informations sur le format de ce fichier. Cependant, une fois que tous les objets du package sont définis, vous avez la possibilité d'inclure des fonctions décrites à la rubrique Ajout de fonctions au fichier prototype.

Exemple : Création d'un fichier prototype à l'aide de la commande pkgproto

Vous pouvez utiliser la commande pkgproto pour créer un fichier prototype de base, à condition d'avoir organisé la structure de répertoires du package de la manière décrite à la rubrique Organisation du contenu d'un package. Par exemple, d'après l'exemple de structure de répertoires et de fichier pkginfo décrit au cours des sections précédentes, les commandes pour créer le fichier prototype sont les suivantes :

$ cd /home/jane
$ pkgproto ./SUNWcadap > InfoFiles/prototype

Le fichier prototype ressemble à ce qui suit :

d none SUNWcadap 0755 jane staff
d none SUNWcadap/demo 0755 jane staff
f none SUNWcadap/demo/file1 0555 jane staff
d none SUNWcadap/srcfiles 0755 jane staff
f none SUNWcadap/srcfiles/file5 0555 jane staff
f none SUNWcadap/srcfiles/file6 0555 jane staff
d none SUNWcadap/lib 0755 jane staff
f none SUNWcadap/lib/file2 0644 jane staff
d none SUNWcadap/man 0755 jane staff
f none SUNWcadap/man/windex 0644 jane staff
d none SUNWcadap/man/man1 0755 jane staff
f none SUNWcadap/man/man1/file4.1 0444 jane staff
f none SUNWcadap/man/man1/file3.1 0444 jane staff

Le propriétaire effectif et le groupe de la personne créant le package sont enregistrés par la commande pkgproto. Une bonne technique consiste à utiliser les commandes chown -R et chgrp -R pour définir le propriétaire et le groupe souhaités avant d'exécuter la commande pkgproto.

Cet exemple de fichier prototype n'est pas terminé. Reportez-vous à la section suivante pour plus d'informations sur l'achèvement de ce fichier.

Derniers ajustements à apporter à un fichier prototype créé à l'aide de la commande pkgproto

Bien que la commande pkgproto soit utile pour créer un fichier prototype initial, elle ne crée pas d'entrées pour tous les objets de package qui doivent être définis. Cette commande ne crée pas des entrées complètes. La commande pkgproto n'effectue pas les opérations suivantes :

• Création d'entrées complètes pour les objets dont le type de fichier est v (fichiers volatiles), e (fichiers modifiables), x (répertoires exclusifs) ou i (fichiers d'information ou scripts d'installation) ;

• Prise en charge de plusieurs classes à l'aide d'un seul appel.

Création d'entrées d'objet dont le type de fichier est v, e, x et i

Vous devez systématiquement modifier le fichier prototype pour ajouter des objets dont le type de fichier est i. Si vous avez stocké vos fichiers d'information et vos scripts d'installation au premier niveau du répertoire de votre package (par exemple, /home/jane/SUNWcadap/pkginfo), une entrée du fichier prototype est comme suit :

i pkginfo

Si vous n'avez pas stocké vos fichiers d'information ni vos scripts d'installation au premier niveau du répertoire de votre package, vous devez spécifier leur emplacement source. Exemple :

i pkginfo=/home/jane/InfoFiles/pkginfo

Vous pouvez également utiliser la commande !search pour spécifier l'emplacement de la commande pkgmk afin de déterminer à quel moment créer le package. Pour plus d'informations, reportez-vous à Offre d'un chemin de recherche pour la commande pkgmk..

Pour ajouter des entrées d'objets dont le type de fichier est v, e et x, respectez le format décrit à la rubrique Format du fichier prototype ou reportez-vous à la page de manuel prototype(4).

N'oubliez pas d'attribuer une classe aux fichiers dont le type est e (modifiable) et d'associer un script d'action de classe à celle-ci. Sans cette classe, les fichiers sont supprimés lors de la désinstallation du package même si le nom de chemin est partagé avec d'autres packages.

Utilisation de plusieurs définitions de classe

Si vous utilisez la commande pkgproto pour créer votre fichier prototype de base, vous pouvez attribuer tous les objets de package à la classe none ou à une classe spécifique. Comme illustré dans l'Exemple : Création d'un fichier prototype à l'aide de la commande pkgproto, la commande pkgproto de base attribue tous les objets à la classe none. Pour attribuer tous les objets à une classe spécifique, vous pouvez utiliser l'option -c. Exemple :

$ pkgproto -c classname /home/jane/SUNWcadap > /home/jane/InfoFiles/prototype

Si vous utilisez plusieurs classes, il peut s'avérer nécessaire de modifier manuellement le fichier prototype pour modifier le champ class de chaque objet. S vous utilisez des classes, vous devez également définir le paramètre CLASSES du fichier pkginfo et rédiger des scripts d'action de classe. L'utilisation de classes est facultative. Cette fonction est traitée en détail à la la rubrique Rédaction de scripts d'action de classe.

Exemple : Derniers ajustements à apporter à un fichier prototype créé à l'aide de la commande pkgproto

Le fichier prototype créé par la commande pkgproto dans l'Exemple : Création d'un fichier prototype à l'aide de la commande pkgproto, requiert plusieurs modifications.

• Le fichier pkginfo doit avoir une entrée.

• Les champs path doivent être remplacés par le format chemin1=chemin2 car la source du package se trouve dans /home/jane . Puisque la source du package est un répertoire hiérarchique et que la commande !search n'effectue pas de recherches de manière récurrente, l'utilisation du format chemin1=chemin2 peut s'avérer plus simple.

• Les champs owner et group doivent contenir le nom des utilisateurs et des groupes existant sur le système cible. Autrement dit, le propriétaire jane génère une erreur car ce propriétaire n'est pas présent sur le système d'exploitation SunOS^TM.

  Le fichier prototype une fois modifié est comme suit :

  i pkginfo=/home/jane/InfoFiles/pkginfo d none SUNWcadap=/home/jane/SUNWcadap 0755 root sys d none SUNWcadap/demo=/home/jane/SUNWcadap/demo 0755 root bin f none SUNWcadap/demo/file1=/home/jane/SUNWcadap/demo/file1 0555 root bin d none SUNWcadap/srcfiles=/home/jane/SUNWcadap/srcfiles 0755 root bin f none SUNWcadap/srcfiles/file5=/home/jane/SUNWcadap/srcfiles/file5 0555 root bin f none SUNWcadap/srcfiles/file6=/home/jane/SUNWcadap/srcfiles/file6 0555 root bin d none SUNWcadap/lib=/home/jane/SUNWcadap/lib 0755 root bin f none SUNWcadap/lib/file2=/home/jane/SUNWcadap/lib/file2 0644 root bin d none SUNWcadap/man=/home/jane/SUNWcadap/man 0755 bin bin f none SUNWcadap/man/windex=/home/jane/SUNWcadap/man/windex 0644 root other d none SUNWcadap/man/man1=/home/jane/SUNWcadap/man/man1 0755 bin bin f none SUNWcadap/man/man1/file4.1=/home/jane/SUNWcadap/man/man1/file4.1 0444 bin bin f none SUNWcadap/man/man1/file3.1=/home/jane/SUNWcadap/man/man1/file3.1 0444 bin bin

Ajout de fonctions au fichier prototype

Outre la définition de chaque objet de package dans le fichier prototype, vous pouvez également effectuer les opérations suivantes :

• Définition d'objets supplémentaires à créer lors de la phase d'installation.

• Création de lien lors de la phase d'installation.

• Distribution de packages sur divers volumes.

• Imbrication de fichiers prototype.

• Définition d'une valeur par défaut pour les champs mode, owner et group.

• Offre d'un chemin de recherche pour la commande pkgmk.

• Définition de variables d'environnement.

Reportez-vous aux sections suivantes pour plus d'informations sur ces modifications.

Définition d'objets supplémentaires à créer lors de la phase d'installation

Vous pouvez utiliser le fichier prototype pour définir des objets qui ne sont pas fournis sur le support d'installation. Au cours de l'installation, la commande pkgadd permet de créer ces objets avec les types de fichier appropriés s'ils n'existent pas déjà au moment de l'installation.

Pour spécifier la création d'un objet sur le système cible, ajoutez l'entrée correspondante dans le fichier prototype pour indiquer le type de fichier approprié.

Pour par exemple créer un répertoire sur le système cible sans le fournir sur le support d'installation, ajoutez l'entrée suivante pour ce répertoire dans le fichier prototype :

d none /directory 0644 root other

Si vous souhaitez créer un fichier vide sur le système cible, l'entrée correspondant à ce fichier dans le fichier prototype doit être comme suit :

f none filename=/dev/null 0644 bin bin

Les seuls objets qui doivent être fournis sur le support d'installation sont les fichiers standard et les scripts de modification (types de fichier e, v, f) et les répertoires requis pour les stocker. Tout autre objet est créé sans référence aux objets, répertoires, tubes nommés, périphériques, liens physiques ni aux liens symboliques fournis.

Création de lien lors de la phase d'installation

Pour créer des liens lors de la phase d'installation, indiquez les informations suivantes dans l'entrée de l'objet lié figurant dans le fichier prototype :

• Son type de fichier l (lien) ou s (lien symbolique) ;

• Le nom de chemin de l'objet lié au format chemin1=chemin2, où chemin1 correspond au fichier de destination et chemin2, au fichier source ; En règle générale, la variable chemin2 d'un lien ne doit jamais être absolue ; elle doit par contre être relative à la section du répertoire de chemin1. Par exemple, l'entrée d'un fichier prototype définissant un lien symbolique peut être comme suit :

  s none etc/mount=../usr/etc/mount

Les liens relatifs sont spécifiés de cette manière que le package soit installé comme étant absolu ou réadressable.

Distribution de packages sur divers volumes

Lorsque vous créez votre package à l'aide de la commande pkgmk, celle-ci effectue les calculs et opérations nécessaires pour organiser le package en plusieurs volumes. Un package à plusieurs volumes est appelé un package segmenté.

Vous pouvez toutefois utiliser le champ facultatif part du fichier prototype pour définir la section dans laquelle l'objet doit être placé. Tout chiffre entré dans ce champ ignore la commande pkgmk et oblige l'élément à être placé dans la section donnée dans le champ. Notez qu'il existe une correspondance exacte entre les sections et volumes des supports amovibles formatés en tant que systèmes de fichiers. Si les volumes sont préattribués par le développeur, la commande pkgmk renvoie une erreur lorsque l'espace est insuffisant sur un des volumes.

Imbrication de fichiers prototype

Vous pouvez créer plusieurs fichiers prototype et les insérer dans le fichier prototype à l'aide de la commande !include. L'imbrication des fichiers facilite leur maintenance.

L'exemple suivant contient trois fichiers prototype. Le fichier principal (prototype) est en cours de modification. Les deux autres fichiers (proto2 et proto3) y sont insérés.

!include /source-dir/proto2
!include /source-dir/proto3

Définition de valeurs par défaut pour les champs mode, owner et group

Pour définir des valeurs par défaut pour les champs mode, owner et group d'objets de package spécifiques, vous pouvez insérer la commande !default dans le fichier prototype. Exemple :

!default 0644 root other

La plage d'application de la commande !default débute à son point d'insertion et s'étend jusqu'à la fin du fichier. La plage d'application de la commande ne s'étend pas aux fichiers imbriqués.

Toutefois, pour les répertoires (type de fichier d) et les fichiers modifiables (type de fichier e) que vous êtes sûr de trouver sur les systèmes cibles (tels que /usr ou /etc/vfstab), vérifiez que les champs mode, owner et group du fichier prototype sont définis sur la valeur point d'interrogation (?). De cette manière, vous n'écrasez aucun paramètre existant susceptible d'avoir été modifié par l'administrateur du site.

Offre d'un chemin de recherche pour la commande pkgmk.

Si l'emplacement source des objets de package diffère de leur emplacement de destination et que vous ne souhaitez pas vous servir du format chemin1=chemin2 comme décrit à la rubrique Remarques sur les emplacements source et de destination des objets, vous pouvez utiliser la commande !search dans le fichier prototype.

Si vous avez par exemple créé un répertoire pkgfiles dans votre répertoire personnel dans lequel vous avez stocké tous vos fichiers d'information et scripts d'installation, vous pouvez spécifier que la recherche s'effectue dans ce répertoire lorsque le package est créé à l'aide de la commande pkgmk.

La commande dans le fichier prototype ressemble à la suivante :

!search /home-dir/pkgfiles

Les demandes de recherche ne s'étendent pas aux fichiers imbriqués. D'autre part, une recherche se limite aux répertoires répertoriés et ne s'effectue pas de manière récurrente.

Définition de variables d'environnement

Vous pouvez également ajouter des commandes au fichier prototype du type !PARAM=valeur. Les commandes de ce type définissent des variables dans l'environnement actuel. Si vous avez créé plusieurs fichiers prototype, notez que cette commande ne s'applique qu'au fichier prototype dans lequel elle est définie.

La variable PARAM peut commencer par une minuscule ou une majuscule. Si la valeur de la variable PARAM est inconnue lors de la phase de création, l'exécution de la commande pkgmk est suspendue et une erreur est renvoyée. Pour plus d'informations sur les différences entre les variables d'installation et les variables de création, reportez-vous à Variables d'environnement d'un package.

Procédure de création d'un fichier prototype à l'aide de la commande pkgproto

Il est plus simple de créer les fichiers d'information et les scripts d'installation avant de créer un fichier prototype. Cet ordre n'est cependant pas obligatoire. Vous pouvez toujours modifier le fichier prototype après avoir modifié le contenu de votre package. Pour plus d'informations sur les fichiers d'information et les scripts d'installation, reportez-vous au Chapitre3Amélioration de la fonctionnalité d'un package (opérations).

1. Si vous ne l'avez pas déjà fait, déterminez les objets de package devant être absolus et ceux devant être réadressables.

   Pour plus d'informations à ce sujet, reportez-vous à Champ path.

2. Organisez les objets de votre package de façon à reproduire leur emplacement sur le système cible.

   Si vous avez déjà organisé vos packages comme décrit à la rubrique Organisation du contenu d'un package, notez qu'il vous faudra peut-être apporter certaines modifications en fonction des décisions que vous avez prises à l'Étape 1. Si vous n'avez pas encore organisé votre package, faîtes-le maintenant. Lorsqu'un package n'est pas organisé, il est impossible d'utiliser la commande pkgproto pour créer un fichier prototype de base.

3. Si votre package contient des objets réadressables collectivement, modifiez le fichier pkginfo pour donner au paramètre BASEDIR la valeur appropriée.

   Exemple :

   BASEDIR=/opt

   Pour plus d'informations sur les objets réadressables collectivement, reportez-vous à la rubrique Objets réadressables collectivement.

4. Si votre package contient des objets réadressables individuellement, créez un script request invitant le programme d'installation à entrer le nom de chemin approprié. Vous pouvez également créer un script checkinstall pour déterminer le chemin approprié à partir des données du système de fichiers.

   La liste suivante indique le numéro de page de référence des opérations courantes :

   • Pour créer un script request, reportez-vous à Procédure de rédaction d'un script request.

   • Pour créer un script checkinstall, reportez-vous à Procédure de recueil de données d'un système de fichiers.

   • Pour plus d'informations sur les objets réadressables individuellement, reportez-vous à la rubrique Objets réadressables individuellement.

5. Faites du propriétaire et du groupe de tous les composants du package le propriétaire et le groupe requis sur les systèmes cibles.

   Utilisez les commandes chown -R et chgrp -R sur le répertoire de votre package et sur les fichiers d'information.

6. Exécutez la commande pkgproto pour créer un fichier prototype de base.

   La commande pkgproto balaye vos répertoires afin de créer un fichier de base. Exemple :

   $ cd package-directory $ pkgproto ./package-directory > prototype

   Le fichier prototype peut se trouver à tout endroit de votre système. La centralisation de vos fichiers d'information et scripts d'installation simplifie l'accès et la maintenance. Pour plus d'informations sur la commande pkgproto, reportez-vous à la page de manuel pkgproto(1).

7. Modifiez le fichier prototype à l'aide d'un éditeur de texte afin d'y ajouter des entrées pour les fichiers de type v, e, x et i.

   Pour plus d'informations sur les modifications spécifiques que vous pouvez avoir à apporter, reportez-vous à Derniers ajustements à apporter à un fichier prototype créé à l'aide de la commande pkgproto.

8. (Facultatif) Si vous utilisez plusieurs classes, modifiez les fichiers prototype et pkginfo. Utilisez un éditeur de texte pour apporter les modifications nécessaires, puis créez les scripts d'action de classe correspondantes.

   Pour plus d'informations sur les modifications spécifiques que vous pouvez avoir à apporter, reportez-vous à Derniers ajustements à apporter à un fichier prototype créé à l'aide de la commande pkgproto et à Rédaction de scripts d'action de classe.

9. Modifiez le fichier prototype à l'aide d'un éditeur de texte afin d'y redéfinir les noms de chemin et autres valeurs de champ.

   Pour plus d'informations, reportez-vous à Derniers ajustements à apporter à un fichier prototype créé à l'aide de la commande pkgproto.

10. (Facultatif) Modifiez le fichier prototype à l'aide d'un éditeur de texte pour lui ajouter des fonctions.

    Pour plus d'informations, reportez-vous à Ajout de fonctions au fichier prototype.

11. Enregistrez les modifications et quittez l'éditeur.

Voir aussi

Si vous êtes prêt à passer à l'étape suivante, reportez-vous à Procédure de création d'un package.