Chapitre 2 Création d'un package

Le présent chapitre décrit la procédure et les opérations liées à la création d'un package. Certaines de ces opérations sont obligatoires. D'autres sont facultatives. Les opérations obligatoires sont traitées en détail dans ce chapitre. Pour plus d'informations sur les opérations facultatives qui permettent d'ajouter d'autres fonctions à votre package, reportez-vous au Chapitre3Amélioration de la fonctionnalité d'un package (opérations) et au Chapitre6Techniques avancées de création de packages.

La liste suivante répertorie les informations disponibles dans le présent chapitre :

• Procédure de création d'un package (liste de tâches)

• Variables d'environnement d'un package

• Création d'un fichier pkginfo

• Organisation du contenu d'un package

• Création d'un fichier prototype

• Création d'un package

Procédure de création d'un package (liste de tâches)

Le Tableau 2–1 décrit une procédure que vous pouvez suivre pour créer des packages, tout particulièrement si vous n'avez aucune expérience en la matière. Bien qu'il ne soit pas obligatoire d'effectuer les quatre premières opérations dans l'ordre indiqué, votre apprentissage sera plus aisé si vous vous y tenez. Avec de l'expérience, vous pourrez changer l'ordre de ces opérations à votre gré.

En tant que concepteur de packages expérimenté, vous pouvez automatiser la procédure de création des packages à l'aide de la commande make et créer des fichiers. Pour plus d'informations, reportez-vous à la page de manuel make(1S).

Variables d'environnement d'un package

Vous pouvez utiliser des variables dans les fichiers d'information obligatoires, pkginfo et prototype. Vous pouvez également utiliser une option dans la commande pkgmk destinée à créer un package. Davantage d'informations contextuelles sur les variables sont fournies tout au long de ce chapitre dans les sections traitant de ces fichiers et commandes. Toutefois, avant de vous lancer dans la création de votre package, il est important de connaître les différents types de variables et de comprendre la manière dont ils influencent le bon déroulement de la création d'un package.

Il existe deux types de variables :

• Variables de création

  Les variables de création commencent par une minuscule et sont évaluées lors de la phase de création, pendant que le package est créé à l'aide de la commande pkgmk.

• Variables d'installation

  Les variables d'installation commencent par une majuscule et sont évaluées lors de la phase d'installation, pendant que le package est installé à l'aide de la commande pkgadd.

Règles globales d'utilisation des variables d'environnement

Dans le fichier pkginfo, la définition d'une variable utilise le format suivant : PARAM=valeur, où la première lettre de PARAM est une majuscule. Ces variables sont évaluées lors de la phase d'installation. Si une ou plusieurs de ces variables ne peuvent être évaluées, l'exécution de la commande pkgadd est suspendue et un message d'erreur est renvoyé.

Dans le fichier prototype, la définition d'une variable peut utiliser le format !PARAM=valeur ou le format $variable. PARAM et variable peuvent tous deux commencer par une majuscule ou une minuscule. Seules les variables dont les valeurs sont connues lors de la phase de création sont évaluées. Si PARAM ou variable est une variable de création ou d'installation dont la valeur est inconnue lors de la phase de création, l'exécution de la commande pkgmk est suspendue et un message d'erreur est renvoyé.

L'option PARAM=valeur peut aussi être incluse dans la commande pkgmk. Cette option fonctionne de la même manière que dans le fichier prototype, excepté qu'elle s'applique à l'ensemble du package. La définition de !PARAM=valeur d'un fichier prototype est locale par rapport à ce fichier et à la section du package à laquelle elle se rapporte.

Si PARAM est une variable d'installation et que variable est une variable d'installation ou de création dont la valeur est connue, la commande pkgmk insère la définition dans le fichier pkginfo pour que celle-ci soit disponible lors de la phase d'installation. Toutefois, la commande pkgmk n'évalue pas les variables PARAM qui sont utilisées dans des chemins spécifiés dans le fichier prototype.

Récapitulatif des variables d'environnement d'un package

Le tableau suivant récapitule les formats de spécification, l'emplacement et le champ d'application des variables.

Création d'un fichier pkginfo

Le fichier pkginfo est un fichier ASCII qui décrit les caractéristiques d'un package, ainsi que les informations permettant de contrôler le déroulement de l'installation.

Chaque entrée du fichier pkginfo est une ligne décrivant la valeur d'un paramètre d'après le format PARAM=valeur. PARAM peut être tout paramètre standard décrit à la page de manuel pkginfo(4) Les paramètres sont spécifiés dans aucun ordre particulier.

Chaque valeur peut être indiquée entre guillemets simples ou doubles (par exemple, 'valeur' ou "valeur"). Si valeur contient des caractères considérés comme spéciaux dans le cadre d'un environnement shell, employez des guillemets. Les exemples et études de cas figurant dans ce guide n'utilisent pas de guillemets. Reportez-vous à la page de manuel pkginfo(4) pour voir un exemple contenant des guillemets doubles.

Vous pouvez également créer vos propres paramètres de package en leur attribuant une valeur dans le fichier pkginfo. Vos paramètres doivent commencer par une majuscule suivie d'autres majuscules ou de minuscules. Une majuscule indique que le paramètre (variable) est évalué lors de la phase d'installation, par opposition à la phase de création. 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.

Tout espace situé à la fin d'une valeur de paramètre est ignoré.

Vous devez définir les cinq paramètres suivants dans un fichier pkginfo : PKG, NAME, ARCH, VERSION et CATEGORY. Les paramètres PATH, PKGINST et INSTDATE sont automatiquement insérés par le logiciel lors de la création du package. Ne modifiez pas ces huit paramètres. Pour plus d'informations sur les autres paramètres, reportez-vous à la page de manuel pkginfo(4).

Définition d'une instance de package

Un même package peut avoir diverses versions ou être compatible avec diverses architectures, voire les deux. Chaque variante d'un package est appelée une instance de package. Une instance de package se définit en alliant les définitions des paramètres PKG, ARCH et VERSION dans le fichier pkginfo.

La commande pkgadd attribue un identificateur de package à chaque instance de package lors de la phase d'installation. L'identificateur de package est composé de l'abréviation du package et d'un suffixe numérique, par exemple SUNWadm.2. Cet identificateur permet de distinguer les instances de package d'un package à l'autre mais aussi celles d'un même package.

Définition de l'abréviation d'un package (PKG)

L'abréviation d'un package est un nom abrégé de package défini par le paramètre PKG dans le fichier pkginfo. L'abréviation d'un package doit présenter les caractéristiques suivantes :

• L'abréviation doit contenir des caractères alphanumériques. Le premier caractère ne peut être un chiffre.

• L'abréviation ne peut pas contenir plus de 32 caractères.

• L'abréviation ne peut pas être une des abréviations réservées suivantes : install, new ou all.

  ---

  Remarque –

  Les quatre premiers caractères doivent être uniques à votre entreprise. Par exemple, les packages créés par Sun Microsystems^TM utilisent tous SUNW comme quatre premiers caractères de l'abréviation de leur package.

  ---

  Exemple d'entrée d'abréviation de package dans le fichier pkginfo : PKG=SUNWcadap.

Spécification d'une architecture de package (ARCH)

Le paramètre ARCH figurant dans le fichier pkginfo identifie les architectures associées au package. Le nom de l'architecture doit être composé de 16 caractères alphanumériques maximum. Si un package est associé à plus d'une architecture, spécifiez les architectures dans une liste en les séparant par des virgules.

Exemple de spécification d'architecture de package dans un fichier pkginfo :

ARCH=sparc

Spécification de l'architecture du jeu d'instructions d'un package (SUNW_ISA)

Le paramètre SUNW_ISA figurant dans le fichier pkginfo identifie l'architecture du jeu d'instructions associé à un package Sun Microsystems. Les valeurs sont les suivantes :

• sparcv9, pour un package contenant des objets 64 bits

• sparc, pour un package contenant des objets 32 bits

Par exemple, la valeur du paramètre SUNW_ISA figurant dans un fichier pkginfo pour un package contenant 64 bits est :

SUNW_ISA=sparcv9

Si SUNW_ISA n'est pas défini, l'architecture du jeu d'instructions par défaut du package est définie sur la valeur du paramètre ARCH.

Spécification de la version d'un package (VERSION)

Le paramètre VERSION figurant dans le fichier pkginfo identifie la version du package. La version se compose de 256 caractères ASCII maximum et ne peut commencer par une parenthèse entrante.

Exemple de la spécification d'une version dans le fichier pkginfo :

VERSION=release 1.0

Définition du nom d'un package (NAME)

Lenom d'un package est le nom complet du package, défini par le paramètre NAME dans le fichier pkginfo.

Étant donné que les administrateurs système se réfèrent souvent au nom d'un package pour déterminer si celui doit ou non être installé, il est important de donner à chaque package un nom clair, précis et non abrégé. Les noms de package doivent répondre aux critères suivants :

• Indiquer dans quelles circonstances le package est requis (par exemple, pour fournir certaines commandes ou fonctionnalités) ou indiquer si le package est requis pour du matériel spécifique.

• Indiquer le cadre d'utilisation du package (par exemple, le développement de pilotes de périphérique).

• Inclure une description du procédé mnémonique de l'abréviation du package, à l'aide de mots clés qui indiquent que l'abréviation représente la description abrégée. Par exemple, le nom de package correspondant à l'abréviation de package SUNWbnuu est Basic Networking UUCP Utilities, (Usr).

• Nommer la partition sur laquelle le package est installé.

• Utiliser des termes tels qu'ils sont utilisés dans l'industrie.

• Exploiter la limite de 256 caractères.

Exemple de nom de package défini dans un fichier pkginfo :

NAME=Chip designers need CAD application software to design
abc chips.  Runs only on xyz hardware and is installed in the
usr partition.

Définition d'une catégorie de package (CATEGORY)

Le paramètre CATEGORY contenu dans le fichier pkginfo spécifie les catégories auxquelles un package appartient. Un package doit appartenir au moins à la catégorie system ou à la catégorie application. Les noms de catégorie sont composés de caractères alphanumériques. Les noms de catégorie peuvent être composés de 16 caractères maximum et ne respectent pas la casse.

Si un package appartient à plus d'une catégorie, spécifiez-les dans une liste en les séparant par des virgules.

Exemple de spécification du paramètre CATEGORY dans le fichier pkginfo :

CATEGORY=system

Procédure de création d'un fichier pkginfo

1. À l'aide d'un éditeur de texte, créez un fichier enregistré sous le nom pkginfo.

   Créez ce fichier sur votre système à l'emplacement de votre choix.

2. Modifiez le fichier et définissez les cinq paramètres obligatoires.

   Les cinq paramètres obligatoires sont les suivants : PKG, NAME, ARCH, VERSION et CATEGORY. Pour plus d'informations sur ces paramètres, reportez-vous à Création d'un fichier pkginfo.

3. Ajoutez au fichier les paramètres facultatifs de votre choix.

   Créez vos propres paramètres ou reportez-vous à la page de manuel pkginfo(4) pour plus d'informations sur les paramètres standard.

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

Exemple 2–1 Création d'un fichier pkginfo

L'exemple suivant illustre le contenu d'un fichier pkginfo correct, dans lequel les cinq paramètres obligatoires et le paramètre BASEDIR sont définis. Le paramètre BASEDIR est abordé plus en détail à la rubrique Champ path.

PKG=SUNWcadap
NAME=Chip designers need CAD application software to design abc chips.  
Runs only on xyz hardware and is installed in the usr partition.
ARCH=sparc
VERSION=release 1.0
CATEGORY=system
BASEDIR=/opt

Voir aussi

Reportez-vous à Procédure d'organisation du contenu d'un package.

Organisation du contenu d'un package

Organisez les objets de votre package en une structure de répertoires hiérarchique qui reproduit la structure des objets du package sur le système cible à l'issue de l'installation. En effectuant cette opération avant de créer un fichier prototype, vous y gagnez en temps et en effort lors de la création du fichier.

Procédure d'organisation du contenu d'un package

1. Déterminez le nombre de packages à créer et les objets de package que chacun d'eux doit contenir.

   Pour plus d'informations sur cette étape, reportez-vous à Critères à prendre en considération avant de créer un package.

2. Créez un répertoire pour chacun des packages à créer.

   Le répertoire peut être créé sur votre système à l'emplacement et avec le nom de votre choix. Les exemples fournis dans le présent chapitre présument que le nom du répertoire d'un package correspond à l'abréviation du package correspondant.

   $ cd /home/jane $ mkdir SUNWcadap

3. Organisez les objets de chaque package dans une structure de répertoires placée dans le répertoire du package correspondant. La structure de répertoires doit reproduire celle prévue pour les objets du package sur le système cible.

   Par exemple, le package d'une application de CAO, SUNWcadap, requiert la structure de répertoires suivante :

   

4. Décidez si les fichiers d'information doivent être conservés. Si nécessaire, créez un répertoire destiné à centraliser tous les fichiers.

   L'exemple suivant présume que l'exemple de fichier pkginfocréé au cours de la rubrique Procédure de création d'un fichier pkginfo est stocké dans le répertoire personnel de l'utilisateur Jane.

   $ cd /home/jane $ mkdir InfoFiles $ mv pkginfo InfoFiles

Voir aussi

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

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.

Création d'un package

Utilisez la commande pkgmk pour créer votre package. La commande pkgmk effectue les opérations suivantes :

• Enregistrement de tous les objets définis dans le fichier prototype au format répertoire.

• Création du fichier pkgmap pour remplacer le fichier prototype.

• Création d'un package pouvant être installé, utilisé comme entrée de la commande pkgadd.

Utilisation de la commande pkgmk la plus simple

La forme la plus simple de cette commande est la commande pkgmk sans aucune option. Avant d'utiliser la commande pkgmk sans aucune option, vérifiez que votre répertoire de travail actuel contient le fichier prototype du package. Les résultats de la commande, des fichiers et des répertoires sont consignés dans le répertoire /var/spool/pkg.

Fichier pkgmap

Lorsque vous créez un package à l'aide de la commande pkgmk, un fichier pkgmap est créé en remplacement du fichier prototype. Le fichier pkgmap de l'exemple précédent contient les données suivantes :

$ more pkgmap
: 1 3170
1 d none SUNWcadap 0755 root sys
1 d none SUNWcadap/demo 0755 root bin
1 f none SUNWcadap/demo/file1 0555 root bin 14868 45617 837527496
1 d none SUNWcadap/lib 0755 root bin
1 f none SUNWcadap/lib/file2 0644 root bin 1551792 62372 837527499
1 d none SUNWcadap/man 0755 bin bin
1 d none SUNWcadap/man/man1 0755 bin bin
1 f none SUNWcadap/man/man1/file3.1 0444 bin bin 3700 42989 837527500
1 f none SUNWcadap/man/man1/file4.1 0444 bin bin 1338 44010 837527499
1 f none SUNWcadap/man/windex 0644 root other 157 13275 837527499
1 d none SUNWcadap/srcfiles 0755 root bin
1 f none SUNWcadap/srcfiles/file5 0555 root bin 12208 20280 837527497
1 f none SUNWcadap/srcfiles/file6 0555 root bin 12256 63236 837527497
1 i pkginfo 140 10941 837531104
$

Le format de ce fichier est très similaire au format du fichier prototype. Toutefois, le fichier pkgmap inclut les informations suivantes :

• La première ligne indique le nombre de volumes balayés par le package et la taille approximative du package une fois installé.

  Par exemple, : 1 3170 indique que le package balaye un seul volume et qu'il utilise environ 3170 blocs de 512 octets une fois installé.

• Trois autres champs définissent la taille, la somme de contrôle et le temps de modification de chaque objet de package.

• Les objets de package sont répertoriés par ordre alphabétique (par classe puis par nom de chemin) pour réduire le temps d'installation du package.

Procédure de création d'un package

1. Si nécessaire, créez un fichier pkginfo.

   Pour une procédure détaillée, reportez-vous à Procédure de création d'un fichier pkginfo.

2. Si nécessaire, créez un fichier prototype.

   Pour une procédure détaillée, reportez-vous à Procédure de création d'un fichier prototype à l'aide de la commande pkgproto.

3. Faites du répertoire contenant le fichier prototype du package votre répertoire de travail.

4. Créez le package.

   $ pkgmk [-o] [-a arch] [-b base-src-dir] [-d device] [-f filename] [-l limit] [-p pstamp] [-r rootpath] [-v version] [PARAM=value] [pkginst]

   -o

   Remplace la version existante du package.

   -a arch

   Remplace les informations sur l'architecture du fichier pkginfo.

   -b rép-src-base

   Demande que rép-src-base soit ajouté au début des noms de chemin réadressables lorsque la commande pkgmk recherche des objets sur le système de création.

   -d périphérique

   Indique que la package doit être copié sur le périphérique qui peut être un nom de chemin de répertoire absolu, une disquette ou un disque amovible.

   -f nomdefichier

   Nomme le fichier nomdefichier utilisé comme fichier prototype. Les noms par défaut sont prototype ou Prototype.

   -l limite

   Spécifie la taille maximale, en blocs de 512 octets, du périphérique de sortie.

   -p horodp

   Remplace la définition de l'horodatage de production figurant dans le fichier pkginfo.

   -r cheminroot

   Demande que le répertoire root cheminroot soit utilisé pour localiser les objets sur le système de développement.

   -v version

   Remplace les informations de version figurant dans le fichier pkginfo.

   PARAM=valeur

   Définit des variables d'environnement globales. Les variables commençant par une minuscule sont résolues lors de la phase de création. Celles qui commencent par une majuscule sont placées dans le fichier pkginfo afin d'être utilisée lors de la phase d'installation.

   instpkg

   Indique un package par son abréviation ou une instance spécifique (par exemple, SUNWcadap.4).

   Pour plus d'informations, reportez-vous à la page de manuel pkgmk(1).

5. Vérifiez le contenu du package.

   $ pkgchk -d device-name pkg-abbrev Checking uninstalled directory format package pkg-abbrev from device-name ## Checking control scripts. ## Checking package objects. ## Checking is complete. $

   -d nom-périphérique

   Indique l'emplacement du package. Notez que nom-périphérique peut être un nom de chemin d'accès à un répertoire complet ou être les identificateurs d'une bande ou d'un disque amovible.

   pkg-abrév

   Correspond au nom d'un ou plusieurs packages à vérifier (séparés par des espaces). En cas d'omission, la commande pkgchk vérifie tous les packages disponibles.

   La commande pkgchk indique quels aspects du package sont vérifiés et, le cas échéant, affiche des avertissements ou des messages d'erreur. Pour plus d'informations sur la commande pkgchk, reportez-vous à Vérification de l'intégrité d'un package.

   ---

   Attention –

   Les erreurs doivent être prises très au sérieux. Une erreur peut indiquer la nécessité de corriger un script. Consultez toutes les erreurs et ignorez-les si vous êtes en désaccord avec le résultat de la commande pkgchk.

   ---

Exemple 2–2 Création d'un package

L'exemple suivant utilise le fichier prototype créé à la rubrique Derniers ajustements à apporter à un fichier prototype créé à l'aide de la commande pkgproto.

$ cd /home/jane/InfoFiles
$ pkgmk
## Building pkgmap from package prototype file.
## Processing pkginfo file.
WARNING: parameter  set to "system990708093144"
WARNING: parameter  set to "none"
## Attempting to volumize 13 entries in pkgmap.
part  1 -- 3170 blocks, 17 entries
## Packaging one part.
/var/spool/pkg/SUNWcadap/pkgmap
/var/spool/pkg/SUNWcadap/pkginfo
/var/spool/pkg/SUNWcadap/reloc/SUNWcadap/demo/file1
/var/spool/pkg/SUNWcadap/reloc/SUNWcadap/lib/file2
/var/spool/pkg/SUNWcadap/reloc/SUNWcadap/man/man1/file3.1
/var/spool/pkg/SUNWcadap/reloc/SUNWcadap/man/man1/file4.1
/var/spool/pkg/SUNWcadap/reloc/SUNWcadap/man/windex
/var/spool/pkg/SUNWcadap/reloc/SUNWcadap/srcfiles/file5
/var/spool/pkg/SUNWcadap/reloc/SUNWcadap/srcfiles/file6
## Validating control scripts.
## Packaging complete.
$

Exemple 2–3 Spécification d'un répertoire source pour les fichiers réadressables

Si votre package contient des fichiers réadressables, vous pouvez utiliser l'option -b rép-src-base de la commande pkgmk pour spécifier un nom de chemin à ajouter au début des noms de chemin réadressables lors de la création du package. Cette option est utile lorsque vous n'avez pas utilisé le format chemin1=chemin2 pour les fichiers réadressables, ni spécifié de chemin de recherche à l'aide de la commande !search dans le fichier prototype.

La commande suivante crée un package doté des caractéristiques suivantes :

• Le package est créé à partir de l'exemple de fichier prototype créé par la commande pkgproto. Reportez-vous à Exemple : Création d'un fichier prototype à l'aide de la commande pkgproto pour plus d'informations.

• Le package est créé sans modifier les champs path.

• Le package ajoute une entrée pour le fichier pkginfo.

$ cd /home/jane/InfoFiles
$ pkgmk -o -b /home/jane
## Building pkgmap from package prototype file.
## Processing pkginfo file.
WARNING: parameter  set to "system960716102636"
WARNING: parameter  set to "none"
## Attempting to volumize 13 entries in pkgmap.
part  1 -- 3170 blocks, 17 entries
## Packaging one part.
/var/spool/pkg/SUNWcadap/pkgmap
/var/spool/pkg/SUNWcadap/pkginfo
/var/spool/pkg/SUNWcadap/reloc/SUNWcadap/demo/file1
/var/spool/pkg/SUNWcadap/reloc/SUNWcadap/lib/file2
/var/spool/pkg/SUNWcadap/reloc/SUNWcadap/man/man1/file3.1
/var/spool/pkg/SUNWcadap/reloc/SUNWcadap/man/man1/file4.1
/var/spool/pkg/SUNWcadap/reloc/SUNWcadap/man/windex
/var/spool/pkg/SUNWcadap/reloc/SUNWcadap/srcfiles/file5
/var/spool/pkg/SUNWcadap/reloc/SUNWcadap/srcfiles/file6
## Validating control scripts.
## Packaging complete.

Dans cet exemple, le package est créé dans le répertoire par défaut, /var/spool/pkg, en spécifiant l'option -o. Cette option remplace le package créé à l'Exemple 2–2.

Exemple 2–4 Spécification de répertoires source distincts pour les fichiers d'information et les objets de package

Si vous placez les fichiers d'information de package (notamment pkginfo et prototype) et les objets de package dans deux répertoires distincts, vous pouvez créer votre package à l'aide des options -b rép-src-base et -r cheminroot dans la commande pkgmk. Si vous placez les objets de package dans un répertoire appelé /product/pkgbin et les autres fichiers d'information de package dans un répertoire appelé /product/pkgsrc, vous pouvez utiliser la commande suivante pour placer le package dans le répertoire /var/spool/pkg :

$ pkgmk -b /product/pkgbin -r /product/pkgsrc -f /product/pkgsrc/prototype

(Facultatif) Vous pouvez utiliser les commandes suivantes pour obtenir le même résultat :

$ cd /product/pkgsrc
$ pkgmk -o -b /product/pkgbin

Dans cet exemple, la commande pkgmk utilise le répertoire de travail actuel pour localiser les autres éléments du package (notamment les fichiers d'information prototype et pkginfo).

Voir aussi

Pour ajouter tout fichier d'information ou script d'installation facultatif à votre package, reportez-vous au Chapitre3Amélioration de la fonctionnalité d'un package (opérations). Sinon, une fois le package créé, vous devez vérifier son intégrité. Le Chapitre4Vérification et transfert d'un package vous explique comment vérifier l'intégrité du package et décrit sa procédure de transfert sur un support de distribution.