ubuntu-packaging-guide - en to fr translation catalogue (394 entries)

en: autopkgtest: Automatic testing for packages
fr: autopkgtest : tests automatiques pour les paquets

en: add a file called ``debian/tests/control`` which specifies the requirements for the testbed,
fr: ajoutez un fichier appelé ``debian/tests/control`` qui spécifie les exigences pour le banc d'essai,

en: add the tests in ``debian/tests/``.
fr: ajoutez les tests dans ``debian/tests/``.

en: Testbed requirements
fr: Exigences du banc d'essai

en: Below we are having a look at the ``glib2.0`` source package. In a very simple case the file would look like this::
fr: Ci-dessous, nous voyons un aperçu du paquet source ``glib2.0``. Dans un cas très simple, le fichier devrait ressembler à ceci::

en: For the test in ``debian/tests/build`` this would ensure that the packages ``libglib2.0-dev`` and ``build-essential`` are installed.
fr: Pour le test dans ``debian/tests/build``, cela permettrait de s'assurer que les paquets ``libglib2.0-dev`` et ``build-essential``  sont installés.

en: You can use ``@`` in the ``Depends`` line to indicate that you want all the packages installed which are built by the source package in question.
fr: Vous pouvez utiliser ``@`` de la ligne ``Depends`` pour indiquer que vous souhaitez tous les paquets installés construits par la paquet source en question.

en: The actual tests
fr: Les tests réels

en: The accompanying test for the example above might be:
fr: Le test accompagnant l'exemple ci-dessus pourrait être :

en: Here a very simple piece of C code is written to a temporary directory. Then this is compiled with system libraries (using flags and library paths as provided by `pkg-config`). Then the compiled binary, which just exercises some parts of core glib functionality, is run.
fr: Ici, un morceau très simple de code C est écrit dans un répertoire temporaire. C'est ensuite compilé avec les bibliothèques système (en utilisant les drapeaux et chemins des bibliothèques fournis par `pkg-config`). Ensuite, le binaire compilé, qui fait juste appel à quelques fonctionnalités glib de parties du noyau, est exécuté.

en: Executing the test
fr: Exécution du test

en: Further examples
fr: Exemples complémentaires

en: This list is not comprehensive, but might help you get a better idea of how automated tests are implemented and used in Ubuntu.
fr: Cette liste n'est pas exhaustive mais elle peut vous aider à mieux comprendre comment les tests automatiques sont implémentés et utilisés dans Ubuntu.

en: Ubuntu infrastructure
fr: infrastructure Ubuntu

en: Getting the test into Ubuntu
fr: Faire passer le test dans Ubuntu

en: The process of submitting an autopkgtest for a package is largely similar to :doc:`fixing a bug in Ubuntu<./fixing-a-bug>`. Essentially you simply:
fr: Le processus de soumission d'un autopkgtest pour un paquet est très similaire à :doc:`corriger un bogue dans Ubuntu<./fixing-a-bug>`. Essentiellement, il vous suffit de :

en: run ``bzr branch ubuntu:<packagename>``,
fr: exécuter ``bzr branch ubuntu:<nomdupaquet>``,

en: edit ``debian/control`` to enable the tests,
fr: modifier ``debian/control`` pour activer les tests,

en: add the ``debian/tests`` directory,
fr: ajouter le répertoire ``debian/tests``,

en: add your test case(s) to ``debian/tests``,
fr: ajouter votre cas de test(s) à ``debian/tests``,

en: commit your changes, push them to Launchpad, propose a merge and get it reviewed just like any other improvement in a source package.
fr: valider vos modifications, les téléverser vers Launchpad, proposer une fusion et obtenir son examen, exactement comme pour  toute autre amélioration dans un paquet source.

en: What you can do
fr: Ce que vous pouvez faire

en: Backporting software updates
fr: Rétroportage de mises à jour logicielles

en: Using a PPA has a number of benefits. It is fairly straight-forward, you don't need approval of anyone, but the downside of it is that your users will have to manually enable it. It is a non-standard software source.
fr: L'utilisation d'un PPA a un certain nombre d'avantages. C'est assez simple, vous n'avez besoin d'aucune approbation, mais l'inconvénient, c'est que vos utilisateurs devront l'activer manuellement. C'est une source de logiciels non standard.

en: Official Ubuntu Backports
fr: Rétroportages officiels d'Ubuntu

en: The Backports Project is a means to provide new features to users. Because of the inherent stability risks in backporting packages, users do not get backported packages without some explicit action on their part. This generally makes backports an inappropriate avenue for fixing bugs. If a package in an Ubuntu release has a bug, it should be fixed either through the :doc:`Security Update or the Stable Release Update process<./security-and-stable-release-updates>`, as appropriate.
fr: Le projet Backports est un moyen d'offrir de nouvelles fonctionnalités aux utilisateurs. En raison des risques inhérents à la stabilité du rétroportage des paquets, les utilisateurs n'obtiennent pas les paquets rétroportés sans action explicite de leur part. Cela rend généralement le rétroportage inapproprié pour corriger les bogues. Si un paquet dans une mise à jour de Ubuntu comporte un bogue, il doit être réparé par la :doc:`Mise à jour de Sécurité ou le Processus de Mise à jour en Version Stable <./security-and-stable-release-updates>`, selon le cas.

en: Once you determined you want a package to be backported to a stable release, you will need to test-build and test it on the given stable release. ``pbuilder-dist`` (in the ``ubuntu-dev-tools`` package) is a very handy tool to do this easily.
fr: Une fois que vous avez déterminé un paquet à rétroporter vers une version stable, vous aurez besoin de le tester y compris en construction sur la version stable donnée. ``pbuilder-dist`` (dans le paquet ``ubuntu-dev-tools``) est un outil très pratique pour y arriver facilement.

en: To report the backport request and get it processed by the Backporters team, you can use the ``requestbackport`` tool (also in the ``ubuntu-dev-tools`` package). It will determine the intermediate releases that package needs to be backported to, list all reverse-dependencies, and file the backporting request.  Also will it include a testing checklist in the bug.
fr: Pour signaler la demande de rétroportage et la faire traiter par l'équipe Backporters, vous pouvez utiliser l'outil ``requestbackport`` (également dans le paquet ``ubuntu-dev-tools``). Il déterminera les versions intermédiaires dans lesquelles le paquet doit être rétroporté, énumérera toutes les dépendances inverses, et déposera la demande de rétroportage. Il inclura également une liste de vérification des tests dans le bogue.

en: Using Chroots
fr: Utilisation des environnements Chroots

en: If you are running one version of Ubuntu but working on packages for another versions you can create the environment of the other version with a ``chroot``.
fr: Si vous utilisez une version d'Ubuntu, mais que vous travaillez sur les paquets pour une autre version, vous pouvez créer l'environnement de l'autre version avec un ``chroot``.

en: A ``chroot`` allows you to have a full filesystem from another distribution which you can work in quite normally.  It avoids the overhead of running a full virtual machine.
fr: Un environnement ``chroot`` vous permet d'avoir un système de fichiers complet d'une autre distribution avec lequel vous pouvez travailler tout à fait normalement. Il évite la surcharge engendrée par l'exécution d'une machine virtuelle complète.

en: Creating a Chroot
fr: Créer un environnement Chroot

en: Use the command ``debootstrap`` to create a new chroot::
fr: Utilisez la commande ``debootstrap`` pour créer un nouvel environnement chroot::

en: You can then work inside the chroot::
fr: Vous pouvez alors travailler dans l'environnement chroot::

en: Where you can install or remove any package you wish without affecting your main system.
fr: Où vous pouvez installer ou désinstaller le paquet que vous souhaitez sans affecter votre système principal.

en: You might want to copy your GPG/ssh keys and Bazaar configuration into the chroot so you can access and sign packages directly::
fr: Vous devriez copier vos clés GPG/ssh et votre configuration Bazaar dans l'environnement chroot de manière à accéder aux paquets et les signer directement::

en: To stop apt and other programs complaining about missing locales you can install your relevant language pack::
fr: Pour empêcher apt et d'autres programmes de se plaindre de l'absence d'informations linguistiques, vous pouvez installer les paquets linguistiques adéquats::

en: If you want to run X programs you will need to bind the /tmp directory into the chroot, from outside the chroot run::
fr: Si vous voulez exécuter des programmes X, vous devez lier le répertoire /tmp dans le chroot, en dehors de chroot, exécutez::

en: Some programs may need you to bind /dev or /proc.
fr: Certains programmes peuvent nécessiter que vous liez /dev ou /proc.

en: You can also set up pbuilder to pause when it comes across a build failure.  Copy C10shell from /usr/share/doc/pbuilder/examples into a directory and use the ``--hookdir=`` argument to point to it.
fr: Vous pouvez également configurer pbuilder pour marquer un arrêt lorsqu'il rencontre un échec de compilation. Copiez C10shell depuis /usr/share/doc/pbuilder/examples dans un répertoire et utilisez l'argument ``--hookdir=`` pour désigner ce dernier.

en: Communication in Ubuntu Development
fr: Communication dans Ubuntu développement

en: In a project where thousands of lines of code are changed, lots of decisions are made and hundreds of people interact every day, it is important to communicate effectively.
fr: Dans un projet où des milliers de lignes de code sont modifiées, de nombreuses décisions sont prises et des centaines de personnes interagissent chaque jour, il est important de communiquer efficacement.

en: Mailing lists
fr: Listes de diffusion

en: Mailing lists are a very important tool if you want to communicate ideas to a broader team and make sure that you reach everybody, even across timezones.
fr: Les listes de diffusion sont un outil très important si vous voulez communiquer des idées à une plus large équipe et vous assurer d'atteindre tout le monde, quels que soient les fuseaux horaires.

en: In terms of development, these are the most important ones:
fr: En termes de développement, ce sont les plus importants :

en: https://lists.ubuntu.com/mailman/listinfo/ubuntu-devel-announce (announce-only, the most important development announcements go here)
fr: https://lists.ubuntu.com/mailman/listinfo/ubuntu-devel-announce (annonces uniquement, les annonces de développement les plus importantes vont ici)

en: https://lists.ubuntu.com/mailman/listinfo/ubuntu-devel (general Ubuntu development discussion)
fr: https://lists.ubuntu.com/mailman/listinfo/ubuntu-devel (discussion générale sur le développement Ubuntu)

en: https://lists.ubuntu.com/mailman/listinfo/ubuntu-motu (MOTU Team discussion, get help with packaging)
fr: https://lists.ubuntu.com/mailman/listinfo/ubuntu-motu (discussion de l'équipe MOTU, obtenir de l'aide avec l'empaquetage)

en: IRC Channels
fr: Canaux IRC

en: For real-time discussions, please connect to irc.freenode.net and join one or any of these channels:
fr: Pour discuter en temps réel, connectez-vous à irc.freenode.net et rejoignez un ou plusieurs de ces canaux :

en: #ubuntu-devel (for general development discussion)
fr: #ubuntu-devel (pour une discussion générale sur le développement)

en: #ubuntu-motu (for MOTU team discussion and generally getting help)
fr: #ubuntu-motu (pour une discussion avec l'équipe MOTU et généralement obtenir de l'aide)

en: Basic Overview of the ``debian/`` Directory
fr: Aperçu élémentaire du dossier ``debian/``

en: This article will briefly explain the different files important to the packaging of Ubuntu packages which are contained in the ``debian/`` directory. The most important of them are ``changelog``, ``control``, ``copyright``, and ``rules``. These are required for all packages. A number of additional files in the ``debian/`` may be used in order to customize and configure the behavior of the package. Some of these files are discussed in this article, but this is not meant to be a complete list.
fr: Cet article va vous expliquer brièvement les différents fichiers importants pour l'empaquetage des paquets Ubuntu, contenus dans le répertoire ``debian/``. Les plus importants d'entre eux sont ``changelog``, ``control``, ``copyright`` et ``rules``. Ceux-ci sont nécessaires pour tous les paquets. Certains fichiers supplémentaires dans ``debian/`` peuvent être utilisés afin de personnaliser et de configurer le comportement du paquet. Certains de ces fichiers sont décrits dans cet article, mais il n'est pas censé constituer une liste exhaustive.

en: The changelog
fr: Le changelog

en: This file is, as its name implies, a listing of the changes made in each version. It has a specific format that gives the package name, version, distribution, changes, and who made the changes at a given time. If you have a GPG key (see: :doc:`Getting set up<./getting-set-up/>`), make sure to use the same name and email address in ``changelog`` as you have in your key. The following is a template ``changelog``::
fr: Ce fichier est, comme son nom l'indique, une liste des modifications apportées à chaque version. Il possède un format spécifique donnant le nom du paquet, la version, la distribution, les modifications, et qui les a apportées à un moment donné. Si vous avez une clé GPG (voir : :doc:`Obtenir configuration<./getting-set-up/>`), assurez-vous d'utiliser les mêmes nom et adresse email dans le ``changelog`` que dans votre clé. Ce qui suit est un modèle de ``changelog`` ::

en: The format (especially of the date) is important. The date should be in :rfc:`5322` format, which can be obtained by using the command ``date -R``. For convenience, the command ``dch`` may be used to edit changelog. It will update the date automatically.
fr: Le format (particulièrement celui de la date) est important. La date doit être au format :rfc:`5322`, obtenu en utilisant la commande ``date -R``. Pour plus de commodité, la commande ``dch`` est utilisée pour éditer le changelog. Elle mettra automatiquement la date à jour.

en: Minor bullet points are indicated by a dash "-", while major points use an asterisk "*".
fr: Les points mineurs sont indiquées par un tiret  "-", tandis que les points majeurs utilisent un astérisque "*".

en: If you are packaging from scratch, ``dch --create`` (``dch`` is in the ``devscripts`` package) will create a standard ``debian/changelog`` for you.
fr: Si vous êtes parti de zéro pour l'empaquetage, ``dch --create`` (``dch`` est dans le paquet ``devscripts``) vous créera un ``debian /changelog`` standard.

en: Here is a sample ``changelog`` file for hello::
fr: Voici un exemple de fichier ``changelog`` pour bonjour::

en: Notice that the version has a ``-0ubuntu1`` appended to it, this is the distro revision, used so that the packaging can be updated (to fix bugs for example) with new uploads within the same source release version.
fr: Notez que la version comporte un ``-0ubuntu1`` annexé, c'est la révision de la distribution, utilisée de telle sorte que l'empaquetage peut être mis à jour (pour par exemple corriger des bogues) avec de nouveaux ajouts dans la même version de la source.

en: Ubuntu and Debian have slightly different package versioning schemes to avoid conflicting packages with the same source version. If a Debian package has been changed in Ubuntu, it has ``ubuntuX`` (where ``X`` is the Ubuntu revision number) appended to the end of the Debian version. So if the Debian hello ``2.6-1`` package was changed by Ubuntu, the version string would be ``2.6-1ubuntu1``. If a package for the application does not exist in Debian, then the Debian revision is ``0`` (e.g. ``2.6-0ubuntu1``).
fr: Ubuntu et Debian ont des systèmes légèrement différents d'incrémentation de version de paquets pour éviter que des paquets issus d'une source de même version entrent en conflit. Lorsqu'un paquet Debian a été modifié dans Ubuntu, il présente un ``ubuntuX``  (où ``X`` est le numéro de révision Ubuntu) annexé à la fin de la version Debian. Donc, si le paquet Debian hello ``2.6-1`` a été modifié par Ubuntu, la chaîne de version indiquera ``2.6-1ubuntu1``. Si ce paquet pour l'application n'existe pas dans Debian, la révision Debian est ``0`` (par exemple, hello ``2.6-0ubuntu1``).

en: The control file
fr: Le fichier de contrôle.

en: The ``control`` file contains the information that the package manager (such as ``apt-get``, ``synaptic``, and ``adept``) uses, build-time dependencies, maintainer information, and much more.
fr: Le fichier ``control`` contient les informations que les gestionnaires de paquets (comme ``apt-get``, ``synaptic`` ou ``adept``) utilisent, les moments de construction des dépendances, les informations concernant les mainteneurs et plus encore.

en: For the Ubuntu ``hello`` package, the ``control`` file looks something like this:
fr: Pour le paquet ``hello`` de Ubuntu, le fichier ``control`` ressemble à ceci :

en: The first paragraph describes the source package including the list of packages required to build the package from source in the ``Build-Depends`` field. It also contains some meta-information such as the maintainer's name, the version of Debian Policy that the package complies with, the location of the packaging version control repository, and the upstream home page.
fr: Le premier paragraphe décrit le paquet source, y compris la liste des paquets nécessaires pour construire le paquet depuis son source dans le champ ``Build-Depends``. Il contient également des méta-informations comme le nom du mainteneur, la version de la Charte Debian à laquelle le paquet se conforme, l'emplacement du dépôt du contrôle de version de l'empaquetage et la page d'accueil en amont.

en: Each additional paragraph describes a binary package to be built.
fr: Chaque paragraphe supplémentaire décrit un paquet binaire à compiler.

en: The copyright file
fr: Le fichier de copyright

en: Generally, copyright information is found in the ``COPYING`` file in the program's source directory. This file should include such information as the names of the author and the packager, the URL from which the source came, a Copyright line with the year and copyright holder, and the text of the copyright itself. An example template would be::
fr: En règle générale, les informations de copyright se trouvent dans le fichier ``COPYING`` du répertoire source du programme. Ce fichier doit contenir des informations telles que les noms des auteurs et de l'empaqueteur, l'URL de provenance de la source, une ligne Copyright indiquant l'année et le titulaire du copyright, et le texte du copyright lui-même. Un exemple pouvant servir de modèle serait ::

en: The rules file
fr: Le fichier des règles

en: The last file we need to look at is ``rules``. This does all the work for creating our package. It is a Makefile with targets to compile and install the application, then create the ``.deb`` file from the installed files. It also has a target to clean up all the build files so you end up with just a source package again.
fr: Le dernier fichier que nous devons examiner est ``rules``. Il complète tout le travail de création de notre paquet. Il s'agit d'un Makefile ayant pour objectifs de compiler et d'installer l'application, puis de créer le fichier ``.deb`` à partir des fichiers installés. Il a également pour objectif de nettoyer tous les fichiers de construction de telle sorte que vous vous retrouvez au final uniquement avec un paquet source.

en: Here is a simplified version of the rules file created by ``dh_make`` (which can be found in the ``dh-make`` package):
fr: Voici une version simplifiée du fichier de règles créé par ``dh_make`` (qui peut être trouvé dans le paquet ``dh-make``):

en: Let us go through this file in some detail. What this does is pass every build target that ``debian/rules`` is called with as an argument to ``/usr/bin/dh``, which itself will call all the necessary ``dh_*`` commands.
fr: Passons ce fichier en revue de détails. Tout ce qu'il fait est de passer chaque cible construite qu'appelle ce ``debian/rules`` comme argument à ``/usr/bin/dh``, qui appelle lui-même toutes les commandes ``dh_*`` nécessaires.

en: ``dh`` runs a sequence of debhelper commands. The supported sequences correspond to the targets of a ``debian/rules`` file: "build", "clean", "install", "binary-arch", "binary-indep", and "binary". In order to see what commands are run in each target, run::
fr: ``dh`` exécute une séquence de commandes de debhelper. Les séquences prises en charge correspondent aux objectifs du fichier « debian/rules » : « build », « clean », « install », « binary-arch », « binary-indep » et « binary ». Afin de voir quelles commandes sont lancées dans chaque cible, exécutez ::

en: Commands in the binary-indep sequence are passed the "-i" option to ensure they only work on binary independent packages, and commands in the binary-arch sequences are passed the "-a" option to ensure they only work on architecture dependent packages.
fr: Les commandes de la séquence binary-indep sont passées avec l'option « -i » pour s'assurer qu'elles ne fonctionnent que sur des paquets binaires indépendants, et les commandes de la séquence binary-arch sont passées avec l'option « -a » pour s'assurer qu'elles ne fonctionnent que sur les paquets dépendants de l'architecture.

en: Each debhelper command will record when it's successfully run in ``debian/package.debhelper.log``. (Which dh_clean deletes.) So dh can tell which commands have already been run, for which packages, and skip running those commands again.
fr: Chaque commande debhelper s'enregistrera après une exécution réussie dans ``debian/package.debhelper.log``. (Que dh_clean efface.) Ainsi, dh peut révéler quelles commandes ont déjà été exécutées, pour quels paquets, et ignorera une nouvelle instance d'exécution de ces commandes.

en: Each time ``dh`` is run, it examines the log, and finds the last logged command that is in the specified sequence. It then continues with the next command in the sequence. The ``--until``, ``--before``, ``--after``, and ``--remaining`` options can override this behavior.
fr: A chaque exécution de ``dh``, il examine le journal, et retrouve les dernières commandes historisées dans une séquence spécifiée. Il continue ensuite avec la commande suivante de la séquence. Les options ``--until``, ``--before``, ``--after``, et ``--remaining`` modifient ce comportement.

en: If ``debian/rules`` contains a target with a name like ``override_dh_command``, then when it gets to that command in the sequence, ``dh`` will run that target from the rules file, rather than running the actual command. The override target can then run the command with additional options, or run entirely different commands instead. (Note that to use this feature, you should Build-Depend on debhelper 7.0.50 or above.)
fr: Si ``debian/rules`` contient une cible nommée ``override_dh_command``, alors quand il arrive à cette commande de la séquence, ``dh`` traitera cette cible à partir du fichier de règles, plutôt que de lancer la commande réelle. La cible modifiée peut ensuite exécuter la commande avec des options supplémentaires, ou exécuter des commandes complètement différentes à la place. (Notez que pour utiliser cette fonctionnalité, vous devez construire les dépendances à partir de debhelper 7.0.50 ou supérieur.)

en: Have a look at ``/usr/share/doc/debhelper/examples/`` and ``man dh`` for more examples. Also see `the rules section (Section 4.9) <http://www.debian.org/doc/debian-policy/ch-source.html#s-debianrules>`_ of the Debian Policy Manual.
fr: Jetez un œil à ``usr/share/doc/debhelper/examples/`` et ``man dh`` pour plus d'exemples. Voir également `la section rules (Section 4.9) <http://www.debian.org/doc/debian-policy/ch-source.html#s-debianrules>`_ de la Charte Debian.

en: Additional Files
fr: Les fichiers additionnels

en: The install file
fr: Le fichier d'installation

en: The ``install`` file is used by ``dh_install`` to install files into the binary package. It has two standard use cases:
fr: Le fichier ``install`` est utilisé par ``dh_install`` pour installer les fichiers dans le paquet binaire. Il s'utilise classiquement dans deux cas :

en: To install files into your package that are not handled by the upstream build system.
fr: Pour installer des fichiers dans votre paquet lorsqu'ils ne sont pas gérés par le système de construction en amont.

en: Splitting a single large source package into multiple binary packages.
fr: Fractionner un important et unique paquet source en plusieurs paquets binaires.

en: In the first case, the ``install`` file should have one line per file installed, specifying both the file and the installation directory. For example, the following ``install`` file would install the script ``foo`` in the source package's root directory to ``usr/bin`` and a desktop file in the ``debian`` directory to ``usr/share/applications``::
fr: Dans le premier cas, le fichier ``install`` doit comporter une ligne par fichier installé, en précisant à la fois le fichier et le répertoire d'installation. Par exemple, le fichier ``install`` suivant installera le script ``foo`` dans le répertoire racine du paquet source de ``usr/bin`` et un fichier desktop dans le répertoire ``debian`` de ``usr/share/applications`` ::

en: When a source package is producing multiple binary packages ``dh`` will install the files into ``debian/tmp`` rather than directly into ``debian/<package>``. Files installed into ``debian/tmp`` can then be moved into separate binary packages using multiple ``$package_name.install`` files. This is often done to split large amounts of architecture independent data out of architecture dependent packages and into ``Architecture: all`` packages. In this case, only the name of the files (or directories) to be installed are needed without the installation directory. For example, ``foo.install`` containing only the architecture dependent files might look like::
fr: Lorsqu'un paquet source produit plusieurs paquets binaires ``dh`` va installer les fichiers dans ``debian/tmp`` plutôt que directement dans ``debian/<paquet>``. Les fichiers installés dans ``debian/tmp`` peuvent alors être déplacés en paquets binaires séparés en utilisant plusieurs fichiers ``$package_name.install``. Cela est couramment utilisé pour sortir de grandes quantités de données indépendantes de l'architecture hors de paquets dépendants de l'architecture ainsi qu'à l'intérieur de paquets ``Architecture : all``. Dans ce cas, seul le nom des fichiers (ou des répertoires) à installer sont nécessaires, en omettant le répertoire d'installation. Par exemple, ``foo.install`` contenant uniquement des fichiers dépendants de l'architecture pourrait ressembler à ::

en: While ``foo-common.install`` containing only the architecture independent file might look like::
fr: Alors que le ``foo-common.install`` contenant uniquement des fichiers indépendants de l'architecture pourrait ressembler à ::

en: This would create two binary packages, ``foo`` and ``foo-common``. Both would require their own paragraph in ``debian/control``.
fr: Cela créera deux paquets binaires, `` foo`` et ``foo-common``. Les deux exigeraient leur propre paragraphe dans ``debian/control``.

en: See ``man dh_install`` and the `install file section (Section 5.11) <http://www.debian.org/doc/manuals/maint-guide/dother.en.html#install>`_  of the Debian New Maintainers' Guide for additional details.
fr: Voir ``man dh_install`` et `la section du fichier install (Section 5.11) <http://www.debian.org/doc/manuals/maint-guide/dother.en.html#install>`_ du Nouveau Guide des Mainteneurs Debian pour plus de détails.

en: The watch file
fr: Le fichier watch

en: The ``debian/watch`` file allows us to check automatically for new upstream versions using the tool ``uscan`` found in the ``devscripts`` package. The first line of the watch file must be the format version (3, at the time of this writing), while the following lines contain any URLs to parse. For example::
fr: Le fichier ``debian/watch`` nous permet de vérifier automatiquement les nouvelles versions amont en utilisant l'outil ``uscan`` se trouvant dans le paquet ``devscripts``. La première ligne du fichier doit être la version du format (3, au moment d'écrire ces lignes), tandis que les lignes suivantes contiennent des URL à analyser. Par exemple::

en: Running ``uscan`` in the root source directory will now compare the upstream version number in ``debian/changelog`` with the latest available upstream version. If a new upstream version is found, it will be automatically downloaded. For example::
fr: L'exécution de ``uscan`` dans le répertoire racine source ira comparer le numéro de version amont dans ``debian/changelog`` avec celui de la dernière version amont disponible. Si une nouvelle version amont est trouvée, elle sera automatiquement téléchargée. Par exemple ::

en: For further information, see ``man uscan`` and the `watch file section (Section 4.11) <http://www.debian.org/doc/debian-policy/ch-source.html#s-debianwatch>`_ of the Debian Policy Manual.
fr: Pour plus d'informations, consultez ``man uscan`` et la `section fichier watch (Section 4.11) <http://www.debian.org/doc/debian-policy/ch-source.html#s-debianwatch>`_ de la Charte Debian.

en: For a list of packages where the ``watch`` file reports they are not in sync with upstream see `Ubuntu External Health Status <http://qa.ubuntuwire.org/uehs/no_updated.html>`_.
fr: Pour une liste de paquets où les fichiers de rapport ``watch`` ne sont pas synchronisés avec l'amont, voir `Etat de santé externe Ubuntu <http://qa.ubuntuwire.org/uehs/no_updated.html>`_.

en: The source/format file
fr: Le fichier source/format

en: This file indicates the format of the source package. It should contain a single line indicating the desired format:
fr: Ce fichier indique le format du paquet source. Il doit contenir une seule ligne indiquant le format désiré :

en: ``3.0 (native)`` for Debian native packages (no upstream version)
fr: ``3.0 (native)`` pour les paquets Debian natifs (pas de version amont)

en: ``3.0 (quilt)`` for packages with a separate upstream tarball
fr: ``3.0 (quilt)`` pour les paquets avec une archive séparée en amont

en: ``1.0`` for packages wishing to explicitly declare the default format
fr: ``1.0`` pour les paquets souhaitant déclarer explicitement le format par défaut

en: Currently, the package source format will default to 1.0 if this file does not exist. You can make this explicit in the source/format file. If you choose not to use this file to define the source format, Lintian will warn about the missing file. This warning is informational only and may be safely ignored.
fr: Actuellement, le format de paquet source sera 1.0 par défaut si ce fichier n'existe pas. Vous pouvez rendre cela explicite dans le fichier source/format. Si vous choisissez de ne pas utiliser ce fichier pour définir le format de la source, Lintian vous avertira de ce fichier manquant. Cet avertissement est purement informatif et peut être ignoré en toute sécurité.

en: You are encouraged to use the newer 3.0 source format. It provides a number of new features:
fr: Nous vous encourageons à utiliser le nouveau format de source 3.0. Il fournit un certain nombre de nouvelles fonctionnalités :

en: Support for additional compression formats: bzip2, lzma and xz
fr: Prise en charge de formats de compression supplémentaires : bzip2, lzma et xz

en: Support for multiple upstream tarballs
fr: Prise en charge de plusieurs archives amont

en: Not necessary to repack the upstream tarball to strip the debian directory
fr: Il n'est pas nécessaire de rempaqueter l'archive amont pour dépouiller le répertoire debian

en: Debian-specific changes are no longer stored in a single .diff.gz but in multiple patches compatible with quilt under ``debian/patches/``
fr: Les changements spécifiques à Debian ne sont plus stockés dans un seul fichier .diff.gz, mais dans plusieurs correctifs compatibles avec quilt dans ``debian/patches/``

en: Additional Resources
fr: Ressources supplémentaires

en: Fixing a bug in Ubuntu
fr: Correction d'un bogue dans Ubuntu

en: If you followed the instructions to :doc:`get set up with Ubuntu Development<./getting-set-up>`, you should be all set and ready to go.
fr: Si vous avez suivi les instructions pour :doc:`obtenir la configuration de Ubuntu Développement<./getting-set-up>`, vous devriez être configuré et prêt à commencer.

en: As you can see in the image above, there is no surprises in the process of fixing bugs in Ubuntu: you found a problem, you get the code, work on the fix, test it, push your changes to Launchpad and ask for it to be reviewed and merged. In this guide we will go through all the necessary steps one by one.
fr: Comme vous pouvez le constater dans l'image ci-dessus, il n'y a pas de surprises dans le processus de correction des bogues dans Ubuntu : vous découvrez un problème, vous obtenez le code, vous travaillez sur le correctif, le testez, soumettez vos modifications dans Launchpad et demandez à ce qu'elles soient examinées puis fusionnées. Dans ce guide, nous allons passer toutes les étapes nécessaires une par une.

en: Finding the problem
fr: Trouver le problème

en: There are a lot of different ways to find things to work on. It might be a bug report you are encountering yourself (which gives you a good opportunity to test the fix), or a problem you noted elsewhere, maybe in a bug report.
fr: Il existe de nombreuses façons de trouver des choses sur lesquelles travailler. Ce sera peut-être un rapport de bogue que vous-même pouvez rencontrer (ce qui vous donne une bonne occasion de tester le correctif), ou un problème relevé par ailleurs, éventuellement dans un rapport de bogue.

en: Figuring out what to fix
fr: Déterminer ce qu'il faut corriger

en: If you don't know the source package containing the code that has the problem, but you do know the path to the affected program on your system, you can discover the source package that you'll need to work on.
fr: Si vous ne connaissez pas le paquet source contenant le code problématique, mais que vous connaissez le chemin du programme concerné sur votre système, vous pouvez découvrir sur quel paquet source vous pourrez travailler.

en: This would print out::
fr: Cela affichera ::

en: ``apt-cache`` is part of the standard installation of Ubuntu.
fr: ``apt-cache`` fait partie de l'installation standard d'Ubuntu.

en: Confirming the problem
fr: Confirmer le problème

en: Let's say the package ``bumprace`` does not have a homepage in its package description. As a first step you would check if the problem is not solved already. This is easy to check, either take a look at Software Center or run::
fr: Supposons que le paquet ``bumprace`` n'a pas de page d'accueil dans sa description de paquet. Dans un premier temps, vous vérifiez si le problème n'est pas déjà résolu. C'est facile à vérifier, soit en jetant un coup d’œil à la Logithèque Ubuntu, soit en exécutant ::

en: The output should be similar to this::
fr: La sortie devrait être similaire à ceci ::

en: A counter-example would be ``gedit``, which has a homepage set::
fr: Un contre-exemple serait ``gedit``, qui dispose d'une page d'accueil ::

en: Sometimes you will find that a particular problem you are looking into is already fixed. To avoid wasting efforts and duplicating work it makes sense to first do some detective work.
fr: Parfois, vous constaterez qu'un problème particulier sur lequel vous vous penchez est déjà corrigé. Pour éviter le gaspillage des efforts et le travail en doublon, il est logique de commencer par un petit travail de détective.

en: Research bug situation
fr: Localisation de bogue

en: First we should check if a bug for the problem exists in Ubuntu already. Maybe somebody is working on a fix already, or we can contribute to the solution somehow. For Ubuntu we have a quick look at https://bugs.launchpad.net/ubuntu/+source/bumprace and there is no open bug with our problem there.
fr: En premier lieu, nous devons vérifier l'existence préalable d'un bogue pour ce problème dans Ubuntu. Peut-être que quelqu'un travaille déjà sur un correctif, ou nous pouvons contribuer à la solution d'une manière ou d'une autre. Pour Ubuntu, nous jetons un coup d’œil à https://bugs.launchpad.net/ubuntu/+source/bumprace et constatons qu'aucun bogue n'y est ouvert avec notre problème.

en: For Ubuntu the URL ``https://bugs.launchpad.net/ubuntu/+source/<package>`` should always take to the bug page of the source package in question.
fr: Pour Ubuntu, l'URL ``https://bugs.launchpad.net/ubuntu/+source/<paquet>`` devrait toujours afficher la page concernant les bogues du paquet source en question.

en: For Debian, which is the major source for Ubuntu's packages, we have a look at http://bugs.debian.org/src:bumprace and can't find a bug report for our problem either.
fr: Pour Debian, qui est la principale source des paquets d'Ubuntu, nous jetons un œil sur http://bugs.debian.org/src:bumprace et nous ne pouvons de nouveau pas trouver de rapport de bogue pour notre problème.

en: For Debian the URL ``http://bugs.debian.org/src:<package>`` should always take to the bug page of the source package in question.
fr: Pour Debian, l'URL ``http://bugs.debian.org/src:<paquet>`` devrait toujours afficher la page concernant les bogues du paquet source en question.

en: The problem we are working on is special as it only concerns the packaging-related bits of ``bumprace``. If it was a problem in the source code it would be helpful to also check the Upstream bug tracker. This is unfortunately often different for every package you have a look at, but if you search the web for it, you should in most cases find it pretty easily.
fr: Le problème sur lequel nous travaillons est spécifique, car il concerne uniquement les bits d'empaquetage liés à ``bumprace``. Si le problème se trouvait dans le code source, il serait utile de vérifier également le traceur de bogues en amont. Malheureusement, il arrive souvent que cela soit différent à chaque paquet examiné ; mais si vous effectuez une recherche sur internet, vous devriez le trouver facilement dans la plupart des cas.

en: Offering help
fr: Offrir de l'aide

en: If you found an open bug and it is not assigned to somebody and you are in a position to fix it, you should comment on it with your solution. Be sure to include as much information as you can: Under which circumstances does the bug occur? How did you fix the problem? Did you test your solution?
fr: Si vous avez trouvé un bogue ouvert, qu'il n'est affecté à personne et que vous êtes en mesure de régler le problème, vous pouvez le commenter avec votre solution. N'oubliez pas d'inclure autant d'informations que possible : dans quelles circonstances se produit le bogue ? Comment avez-vous résolu le problème ? Avez-vous testé votre solution ?

en: If no bug report has been filed, you can file a bug for it. What you might want to bear in mind is: Is the issue so small that just asking for somebody to commit it is good enough? Did you manage to only partially fix the issue and you want to at least share your part of it?
fr: Si aucun rapport de bogue n'a été déposé, vous pouvez en déposer un. Une chose que vous devriez garder à l'esprit est : Le problème est-il si petit qu'une simple demande de réalisation serait suffisante ? Avez-vous réussi à partiellement résoudre le problème et vous voulez au moins partager votre partie de la solution ?

en: It is great if you can offer help and will surely be appreciated.
fr: C'est très bien si vous pouvez offrir votre aide, et elle sera assurément appréciée.

en: Getting the code
fr: Obtenir le code

en: Work on a fix
fr: Travailler sur un correctif

en: There are entire books written about finding bugs, fixing them, testing them, etc. If you are completely new to programming, try to fix easy bugs such as obvious typos first. Try to keep changes as minimal as possible and document your change and assumptions clearly.
fr: Il existe des livres entiers sur la façon de trouver des bogues, de les corriger, de les tester, etc. Si vous êtes complètement novice en programmation, essayez en premier lieu de corriger les bogues simples comme les fautes de frappe évidentes. Essayez de minimiser les changements autant que possible et documentez clairement vos modifications et hypothèses.

en: Before working on a fix yourself, make sure to investigate if nobody else has fixed it already or is currently working on a fix. Good sources to check are:
fr: Avant de travailler sur un correctif vous-même, assurez-vous de vérifier que personne d'autre ne l'a déjà corrigé ou est en train de le faire. Les bonnes sources à vérifier sont :

en: Upstream (and Debian) bug tracker (open and closed bugs),
fr: Traceur de bogues en amont (et dans Debian) (bogues ouverts et fermés),

en: Upstream revision history (or newer release) might have fixed the problem,
fr: Historique des révisions en amont (ou version plus récente) pourrait avoir résolu le problème,

en: bugs or package uploads of Debian or other distributions.
fr: des bogues ou des ajouts de paquets de distributions Debian ou autres.

en: This will copy the packaging to a temporary directory.  You can now edit files with a text editor or apply patches from upstream, for example::
fr: Cela va copier l'empaquetage dans un répertoire temporaire. Vous pouvez maintenant éditer les fichiers avec un éditeur de texte ou appliquer des correctifs en amont, par exemple::

en: After editing the file type ``exit`` or press ``control-d`` to quit the temporary shell.  The new patch will have been added into ``debian/patches``.
fr: Après avoir modifié le fichier, saisissez ``exit`` ou appuyez sur ``ctrl-d`` pour quitter l'environnement temporaire. Le nouveau correctif a été ajouté dans ``debian/patches``.

en: Documenting the fix
fr: Documenter le correctif

en: It is very important to document your change sufficiently so developers who look at the code in the future won't have to guess what your reasoning was and what your assumptions were. Every Debian and Ubuntu package source includes ``debian/changelog``, where changes of each uploaded package are tracked.
fr: Il est très important de documenter abondamment vos modifications afin que les développeurs qui reliront votre code dans le futur n'aient pas à deviner ce qu'étaient votre raisonnement et vos hypothèses. Chaque paquet source Debian et Ubuntu inclut ``debian/changelog``, où les modifications de chaque paquet téléchargé sont suivies.

en: The easiest way to update this is to run::
fr: Le moyen le plus simple de mettre à jour est d'exécuter ::

en: This will add a boilerplate changelog entry for you and launch an editor where you can fill in the blanks. An example of this could be::
fr: Cela vous ajoute une entrée passe-partout du changelog et lance un éditeur dans lequel vous pourrez remplir les blancs. Un exemple de ceci pourrait être ::

en: ``dch`` should fill out the first and last line of such a changelog entry for you already. Line 1 consists of the source package name, the version number, which Ubuntu release it is uploaded to, the urgency (which almost always is 'low'). The last line always contains the name, email address and timestamp (in :rfc:`5322` format) of the change.
fr: ``dch`` doit déjà remplir pour vous la première et la dernière ligne d'une telle entrée du changelog. La ligne 1 se compose du nom du paquet source, du numéro de version, de la version d'Ubuntu vers laquelle le paquet est transféré, du niveau d'urgence (qui est presque toujours «{nbsp]faible »). La dernière ligne contient toujours le nom, l'adresse électronique et l'horodatage du changement (au format :rfc:`5322`).

en: With that out of the way, let's focus on the actual changelog entry itself: it is very important to document:
fr: Ces préoccupations en moins, concentrons-nous sur l'entrée effective du changelog elle-même : il est très important de renseigner :

en: In our (very sparse) example the last point is covered by ``(LP: #123456)`` which refers to Launchpad bug 123456. Bug reports or mailing list threads or specifications are usually good information to provide as a rationale for a change. As a bonus, if you use the ``LP: #<number>`` notation for Launchpad bugs, the bug will be automatically closed when the package is uploaded to Ubuntu.
fr: Dans notre (très rare) exemple, le dernier point est couvert par ``(LP: #123456)`` se référant au bogue Launchpad 123456. Les rapports de bogues ou des fils de listes de diffusion ou les spécifications sont généralement de bonnes informations à fournir comme justification d'un changement. En prime, si vous utilisez la notation ``LP: #<numéro>`` pour les bogues sur Launchpad, le bogue sera automatiquement fermé quand le paquet correctif sera téléchargé vers Ubuntu.

en: Testing the fix
fr: Tester le correctif

en: To build a test package with your changes, run these commands::
fr: Pour construire un paquet de test avec vos modifications, exécutez ces commandes::

en: In a lot of cases you will have to actually install the package to make sure it works as expected. Our case is a lot easier. If the build succeeded, you will find the binary packages in ``~/pbuilder/<release>_result``. Install them via ``sudo dpkg -i <package>.deb`` or by double-clicking on them in your file manager.
fr: Dans de nombreux cas vous devrez réellement installer le paquet pour vous assurer qu'il fonctionne comme prévu. Notre cas est largement plus simple. Si la construction réussit, vous trouverez les paquets binaires dans ``~/pbuilder/<release>_result``. Installez-les à l'aide de la commande ``sudo dpkg -i <package>.deb`` ou en double-cliquant dessus dans votre gestionnaire de fichiers.

en: This will take you through a series of steps to make sure the bug ends up in the correct place. Be sure to review the diff again to make sure it does not include random changes you made earlier.
fr: Cela vous mènera à travers une série de mesures pour vous assurer que le bogue se retrouve au bon endroit. Assurez-vous de contrôler de nouveau la différence pour être certain qu'elle ne comprenne aucune modification antérieure non désirée.

en: Communication is important, so when you add some more description to it to the inclusion request, be friendly, explain it well.
fr: La communication est importante, lorsque vous ajoutez une description à votre demande d'inclusion, soyez gentil de bien l'expliquer.

en: If everything went well you should get a mail from Debian's bug tracking system with more information. This might sometimes take a few minutes.
fr: Si tout s'est bien déroulé, vous obtenez un message du système de suivi des bogues Debian avec plus d'informations. Cela peut parfois prendre quelques minutes.

en: Additional considerations
fr: Considérations supplémentaires

en: If you find a package and find that there are a couple of trivial things you can fix at the same time, do it. This will speed up review and inclusion.
fr: Si vous trouvez qu'il y a un certain nombre de choses triviales possibles à corriger en même temps dans un paquet, faites-le. Cela permettra d'accélérer l'examen et l'inclusion.

en: If there are multiple big things you want to fix, it might be advisable to send individual patches or merge proposals instead. If there are individual bugs filed for the issues already, this makes it even easier.
fr: S'il y a plusieurs choses importantes que vous souhaitez corriger, il pourrait être plus judicieux d'envoyer des correctifs individuels ou de fusionner des propositions. S'il y a déjà des bogues individuels déposés sur le sujet, cela rend la chose encore plus aisée.

en: Fixing FTBFS packages
fr: Réparation de paquets FTBFS

en: Before a package can be used in Ubuntu, it has to build from source. If it fails this, it will probably wait in -proposed and will not be available in the Ubuntu archives. You can find a complete list of packages that are failing to build from source at http://qa.ubuntuwire.org/ftbfs/. There are 5 main categories shown on the page:
fr: Avant qu'un paquet puisse être utilisé dans Ubuntu, il doit être compilé depuis le source. S'il échoue (on le qualifie en anglais de FTBFS « Fails To Build From Source »), il attendra probablement dans -proposed et ne sera pas disponible dans les archives Ubuntu. Vous trouverez une liste complète des paquets qui échouent à compiler depuis le source sur http://qa.ubuntuwire.org/ftbfs/. Il y a 5 catégories principales affichées sur la page :

en: Package failed to build (F): Something actually went wrong with the build process.
fr: Package failed to build (F) : (Compilation du paquet a échoué) Quelque chose s'est réellement mal passé pendant la compilation.

en: Cancelled build (X): The build has been cancelled for some reason. These should probably be avoided to start with.
fr: Cancelled build (X) : (Compilation annulée) Le processus de compilation a été annulé pour une raison ou une autre. Il faudrait probablement éviter de débuter avec.

en: Package is waiting on another package (M): This package is waiting on another package to either build, get updated, or (if the package is in main) one of it's dependancies is in the wrong part of the archive.
fr: Package is waiting on another package (M): (Le paquet attend un autre paquet) Ce paquet attend un autre paquet pour compiler, être mis à jour ou (si le paquet est dans main) une de ses dépendances est dans une mauvaise partie de l'archive.

en: Failure in the chroot (C): Part of the chroot failed, this is most likely fixed by a rebuild. Ask a developer to rebuild the package and that should fix it.
fr: Failure in the chroot (C) : (Échec dans le chroot) Une partie du chroot a échoué, cela a de bonnes chances d'être réparé par une recompilation. Demandez à un développeur de recompiler le paquet et il devrait être réparé.

en: Failed to upload (U): The package could not upload. This is usually just a case of asking for a rebuild, but check the build log first.
fr: Failed to upload (U) : (Échec du téléversement) Le paquet n'a pas pu être téléversé. Habituellement, il suffit juste de recompiler, mais vérifiez d'abord le journal de compilation.

en: First steps
fr: Premiers pas

en: The first thing you'll want to do is see if you can reproduce the FTBFS yourself. Get the code either by running ``bzr branch lp:ubuntu/PACKAGE`` and then getting the tarball or running ``dget PACKAGE_DSC`` on the .dsc file from the launchpad page. Once you have that, build it in a schroot.
fr: La première chose que vous devrez faire est de voir si vous pouvez reproduire vous-même le FTBFS. Récupérez le code soit en exécutant ``bzr branch lp:ubuntu/PACKAGE`` et en récupérant le tarball, soit en exécutant ``dget PACKAGE_DSC``sur le fichier .dsc depuis la page launchpad. Une fois que vous l'avez, compilez-le dans un schroot.

en: You should be able to reproduce the FTBFS. If not, check if the build is downloading a missing dependency, which means you just need to make that a build-dependency in debian/control. Building the package locally can also help find if the issue is caused by a missing, unlisted, dependency (builds locally but fails on a schroot).
fr: Vous devriez pouvoir reproduire le FTBFS. Sinon, vérifiez si la compilation télécharge une dépendance manquante, ce qui signifie que vous avez juste besoin d'en faire une dépendance de compilation dans debian/control. Compiler le paquet localement peut aussi aider à trouver si le problème est causé par une dépendance manquante, non listée (compile localement mais échoue sur un schroot).

en: Checking Debian
fr: Vérification de Debian

en: Once you have reproduced the issue, it's time to try and find a solution. If the package is in Debian as well, you can check if the package builds there by going to http://packages.qa.debian.org/PACKAGE. If Debian has a newer version, you should merge it. If not, check the buildlogs and bugs linked on that page for any extra information on the ftbfs or patches. Debian also maintains a list of command FTBFSs and how to fix them which can be found at https://wiki.debian.org/qa.debian.org/FTBFS, you will want to check it for solutions too.
fr: Une fois que vous avez reproduit le problème, il est temps d'essayer de trouver une solution. Si le paquet est aussi dans Debian, vous pouvez vérifier s'il y compile en allant à http://packages.qa.debian.org/PACKAGE. Si Debian a une version plus récente, vous devriez la fusionner. Sinon, recherchez dans les journaux de compilation et les bogues répertoriés sur cette page s'il y a des informations supplémentaires sur les ftbfs ou les correctifs. Debian tient aussi à jour une liste de commandes FTBFS (commandes qui font échouer la compilation) et ce qu'il convient de faire pour les corriger que vous trouverez à https://wiki.debian.org/qa.debian.org/FTBFS, vous devez aussi y rechercher des solutions.

en: Other causes of a package to FTBFS
fr: Autres causes de paquets FTBFS

en: If a package is in main and missing a dependency that is not in main, you will have to file a MIR bug. https://wiki.ubuntu.com/MainInclusionProcess explains the procedure.
fr: Si un paquet se trouvant dans main a une dépendance manquante qui n'est pas dans main, vous devrez déposer un rapport de bogue MIR. https://wiki.ubuntu.com/MainInclusionProcess explique la procédure.

en: Fixing the issue
fr: Résoudre le problème

en: Once you have found a fix to the problem, follow the same process as any other bug. Make a patch, add it to a bzr branch or bug, subscribe ubuntu-sponsors, then try to get it included upstream and/or in Debian.
fr: Une fois que vous avez trouvé comment corriger le problème, suivez la même démarche que pour tout autre bogue. Créez un correctif, ajoutez-le à une branche bzr ou à un bogue, abonnez-y ubuntu-sponsors, puis essayez de le faire inclure en amont et/ou dans Debian.

en: Getting Set Up
fr: Mise en route

en: There are a number of things you need to do to get started developing for Ubuntu. This article is designed to get your computer set up so that you can start working with packages, and upload your packages to Ubuntu's hosting platform, Launchpad. Here's what we'll cover:
fr: Un certain nombre de choses doivent être accomplies pour commencer à développer pour Ubuntu. Cet article est conçu pour configurer votre ordinateur de sorte que vous puissiez commencer à travailler avec des paquets, puis télécharger vos paquets vers la plate-forme d'hébergement d'Ubuntu, Launchpad. Voici ce que nous allons aborder :

en: Installing packaging-related software. This includes:
fr: Installation des logiciels relatifs à l'empaquetage. Cela comprend :

en: Ubuntu-specific packaging utilities
fr: Les utilitaires d'empaquetage spécifiques à Ubuntu

en: Encryption software so your work can be verified as being done by you
fr: Logiciel de chiffrement afin que votre travail soit reconnu comme étant bien réalisé par vous

en: Additional encryption software so you can securely transfer files
fr: Logiciel de chiffrement supplémentaire afin de transférer des fichiers en toute sécurité

en: Creating and configuring your account on Launchpad
fr: Création et configuration de votre compte sur Launchpad

en: Setting up your development environment to help you do local builds of packages, interact with other developers, and propose your changes on Launchpad.
fr: Configuration de votre environnement de développement pour vous aider à construire des paquets localement, à interagir avec d'autres développeurs, et à proposer vos modifications sur Launchpad.

en: It is advisable to do packaging work using the current development version of Ubuntu. Doing so will allow you to test changes in the same environment where those changes will actually be applied and used.
fr: Il est conseillé de travailler sur l'empaquetage en utilisant la version de développement actuelle d'Ubuntu. Procéder ainsi vous permettra de tester les modifications dans le même environnement où elles seront effectivement appliquées et utilisées.

en: Install basic packaging software
fr: Installer les logiciels d'empaquetage de base

en: This command will install the following software:
fr: Cette commande va installer les logiciels suivants :

en: ``pbuilder`` -- a tool to do reproducible builds of a package in a clean and isolated environment.
fr: ``pbuilder`` -- un outil pour réaliser des constructions reproductibles d'un paquet dans un environnement propre et isolé.

en: ``ubuntu-dev-tools`` (and ``devscripts``, a direct dependency) -- a collection of tools that make many packaging tasks easier.
fr: ``ubuntu-dev-tools`` (et ``devscripts``, sa dépendance directe) -- une collection d'outils simplifiant les nombreuses tâches d'empaquetage.

en: ``apt-file`` provides an easy way to find the binary package that contains a given file.
fr: ``apt-file`` donne un moyen facile de trouver le paquet binaire contenant un fichier donné.

en: Create your GPG key
fr: Créez votre clé GPG

en: To generate a new GPG key, run::
fr: Pour générer une nouvelle clé GPG, exécutez ::

en: GPG will first ask you which kind of key you want to generate. Choosing the default (RSA and DSA) is fine. Next it will ask you about the keysize. The default (currently 2048) is fine, but 4096 is more secure. Afterwards, it will ask you if you want it to expire the key at some stage. It is safe to say "0", which means the key will never expire. The last questions will be about your name and email address. Just pick the ones you are going to use for Ubuntu development here, you can add additional email addresses later on. Adding a comment is not necessary. Then you will have to set a passphrase, choose a safe one (a passphrase is just a password which is allowed to include spaces).
fr: GPG vous demandera d'abord le type de clé que vous souhaitez générer. Le choix par défaut (RSA et DSA) convient. Ensuite, il vous demandera la taille de clé. La valeur par défaut (actuellement 2048) est correcte, mais 4096 est plus sécurisé. Par la suite, il vous sera demandé si vous souhaitez faire expirer la clé à un certain stade. Vous pouvez sans danger indiquer "0", ce qui signifie que la clé n'expirera jamais. Les dernières questions seront à propos de votre nom et de votre adresse de courriel. Il suffit ici de choisir ceux que vous allez utiliser pour le développement d'Ubuntu, vous pourrez ajouter des adresses de courriel supplémentaires plus tard. Ajouter un commentaire n'est pas nécessaire. Ensuite, vous devrez définir une phrase secrète, choisissez-en une sûre (une phrase secrète est juste un mot de passe qui autorise les espaces).

en: Now GPG will create a key for you, which can take a little bit of time; it needs random bytes, so if you give the system some work to do it will be just fine.  Move the cursor around, type some paragraphs of random text, load some web page.
fr: GPG va maintenant vous créer une clé, ce qui peut prendre un peu de temps ; comme GPG a besoin d'octets aléatoires, il serait souhaitable que vous donniez quelques tâches à réaliser au système. Déplacez le curseur, tapez quelques paragraphes de texte aléatoire, chargez quelques pages dans votre navigateur internet, etc.

en: Once this is done, you will get a message similar to this one::
fr: Une fois cela fait, vous obtiendrez un message similaire à celui-ci ::

en: In this case ``43CDE61D`` is the *key ID*.
fr: Dans ce cas ``43CDE61D`` est l'*identifiant clé*.

en: Next, you need to upload the public part of your key to a keyserver so the world can identify messages and files as yours. To do so, enter::
fr: Ensuite, vous devez envoyer la partie publique de votre clé à un serveur de sorte que tout le monde puisse identifier vos messages et fichiers. Pour ce faire, entrez ::

en: This will send your key to the Ubuntu keyserver, but a network of keyservers will automatically sync the key between themselves. Once this syncing is complete, your signed public key will be ready to verify your contributions around the world.
fr: Cela enverra votre clé au serveur de trousseau d'Ubuntu, inclus dans un réseau d'autres serveurs de trousseaux qui se synchroniseront entre eux. Une fois cette synchronisation terminée, votre clé publique signée sera prête à vérifier vos contributions partout dans le monde.

en: Create your SSH key
fr: Créez votre clé SSH

en: SSH_ stands for *Secure Shell*, and it is a protocol that allows you to exchange data in a secure way over a network. It is common to use SSH to access and open a shell on another computer, and to use it to securely transfer files. For our purposes, we will mainly be using SSH to securely upload source packages to Launchpad.
fr: SSH_ signifie *Secure Shell* , le protocole permettant d'échanger des données de façon sécurisée sur un réseau. Il est courant d'utiliser SSH pour accéder à un environnement, l'ouvrir sur un autre ordinateur et l'utiliser pour transférer des fichiers en toute sécurité. Dans notre cas, nous allons principalement utiliser SSH pour télécharger en toute sécurité nos paquets source vers Launchpad.

en: To generate an SSH key, enter::
fr: Pour générer une clé SSH, saisissez ::

en: The default file name usually makes sense, so you can just leave it as it is. For security purposes, it is highly recommended that you use a passphrase.
fr: Le nom de fichier par défaut est généralement logique, vous pouvez donc simplement le laisser tel quel. Pour des raisons de sécurité, il est fortement recommandé d'utiliser une phrase secrète.

en: Set up pbuilder
fr: Configurer pbuilder

en: ``pbuilder`` allows you to build packages locally on your machine. It serves a couple of purposes:
fr: ``pbuilder`` vous permet de construire des paquets en local sur votre machine. Il dispose de différentes fonctions :

en: The build will be done in a minimal and clean environment. This helps you make sure your builds succeed in a reproducible way, but without modifying your local system
fr: La construction se fera dans un environnement minimal et propre. Cela vous aide à vous assurer que vos constructions réussiront de façon reproductible, mais sans modifier votre système local

en: There is no need to install all necessary *build dependencies* locally
fr: Il est inutile d'installer toutes les *dépendances de construction* nécessaires en local

en: You can set up multiple instances for various Ubuntu and Debian releases
fr: Vous pouvez configurer plusieurs instances pour différentes versions d'Ubuntu et de Debian

en: Setting ``pbuilder`` up is very easy, run::
fr: Configurer ``pbuilder`` est très simple, lancez ::

en: Get set up to work with Launchpad
fr: Mettez vous en place pour travailler avec Launchpad

en: With a basic local configuration in place, your next step will be to configure your system to work with Launchpad. This section will focus on the following topics:
fr: Avec l'installation d'une configuration de base en local, la prochaine étape sera de configurer votre système pour travailler avec Launchpad. Cette section portera sur les sujets suivants :

en: What Launchpad is and creating a Launchpad account
fr: Description de Launchpad et création d'un compte Launchpad

en: Uploading your GPG and SSH keys to Launchpad
fr: Téléversement de vos clés GPG et SSH vers Launchpad

en: About Launchpad
fr: À propos de Launchpad

en: Launchpad is the central piece of infrastructure we use in Ubuntu. It not only stores our packages and our code, but also things like translations, bug reports, and information about the people who work on Ubuntu and their team memberships.  You will also use Launchpad to publish your proposed fixes, and get other Ubuntu developers to review and sponsor them.
fr: Launchpad est la pièce maîtresse de l'infrastructure que nous utilisons dans Ubuntu. Il stocke non seulement nos paquets et notre code, mais également d'autres choses comme les traductions, les rapports de bogues et les informations sur les personnes qui travaillent sur Ubuntu et leurs équipiers. Vous pourrez également utiliser Launchpad pour publier vos propositions de corrections et obtenir leur examen et leur parrainage par d'autres développeurs d'Ubuntu.

en: You will need to register with Launchpad and provide a minimal amount of information. This will allow you to download and upload code, submit bug reports, and more.
fr: Vous devez vous inscrire à Launchpad et fournir un minimum d'informations. Cela vous permettra de télécharger du code depuis et vers Launchpad, de soumettre des rapports de bogues et plus encore.

en: Besides hosting Ubuntu, Launchpad can host any Free Software project. For more information see the `Launchpad Help wiki <https://help.launchpad.net/>`_.
fr: Outre l'hébergement d'Ubuntu, Launchpad peut accueillir tout projet de logiciel libre. Pour plus d'informations, voir le `wiki Aide de Launchpad <https://help.launchpad.net/>`_.

en: Get a Launchpad account
fr: Créer un compte Launchpad

en: Launchpad's registration process will ask you to choose a display name. It is encouraged for you to use your real name here so that your Ubuntu developer colleagues will be able to get to know you better.
fr: Le processus d'inscription à Launchpad vous demandera de choisir un nom à afficher. Il vous est recommandé d'utiliser votre vrai nom, afin que vos collègues développeurs sur Ubuntu soient en mesure de mieux vous connaître.

en: When you register a new account, Launchpad will send you an email with a link you need to open in your browser in order to verify your email address. If you don't receive it, check in your spam folder.
fr: Lorsque vous enregistrez un nouveau compte, Launchpad envoie un courriel avec un lien que vous devez ouvrir dans votre navigateur afin de faire vérifier votre adresse de courriel. Si vous ne le recevez pas, vérifiez dans votre dossier de pourriel.

en: Upload your GPG key to Launchpad
fr: Téléversez votre clé GPG sur Launchpad

en: To find about your GPG fingerprint, run::
fr: Pour connaître votre empreinte GPG, exécutez ::

en: and it will print out something like::
fr: et cela affichera quelque chose comme ::

en: Head to https://launchpad.net/~/+editpgpkeys and copy the "Key fingerprint" into the text box. In the case above this would be ``5C28 0144 FB08 91C0 2CF3  37AC 6F0B F90F 43CD E61D``. Now click on "Import Key".
fr: Dirigez-vous vers https://launchpad.net/~/+editpgpkeys et copiez le fichier "Key fingerprint" dans la zone de texte. Dans le cas ci-dessus ce serait ``5C28 0144 FB08 91C0 2CF3 37AC 6F0B F90F 43CD E61D``. Ensuite, cliquez sur "Importer la clé".

en: Launchpad will use the fingerprint to check the Ubuntu key server for your key and, if successful, send you an encrypted email asking you to confirm the key import. Check your email account and read the email that Launchpad sent you. `If your email client supports OpenPGP encryption, it will prompt you for the password you chose for the key when GPG generated it. Enter the password, then click the link to confirm that the key is yours.`
fr: Launchpad utilise l'empreinte pour vérifier votre clé sur le serveur de trousseau d'Ubuntu et, en cas de succès, vous envoie un courriel crypté vous demandant de confirmer l'import de la clé. Vérifiez votre compte de messagerie et lisez le courriel envoyé par Launchpad. `Si votre client de messagerie prend en charge le chiffrement OpenPGP, il vous demandera d'entrer le mot de passe choisi pour la clé lors de la génération GPG. Entrez le mot de passe, puis cliquez sur le lien pour confirmer que la clé est la vôtre.`

en: Back on the Launchpad website, use the Confirm button and Launchpad will complete the import of your OpenPGP key.
fr: De retour sur le site Launchpad, utilisez le bouton "Confirmer" et Launchpad terminera l'import de votre clé OpenPGP.

en: Find more information at https://help.launchpad.net/YourAccount/ImportingYourPGPKey
fr: Vous trouverez plus d'informations sur https://help.launchpad.net/YourAccount/ImportingYourPGPKey

en: Upload your SSH key to Launchpad
fr: Téléchargez votre clé SSH vers Launchpad

en: Open https://launchpad.net/~/+editsshkeys in a web browser, also open ``~/.ssh/id_rsa.pub`` in a text editor. This is the public part of your SSH key, so it is safe to share it with Launchpad. Copy the contents of the file and paste them into the text box on the web page that says "Add an SSH key". Now click "Import Public Key".
fr: Ouvrez https://launchpad.net/~/+editsshkeys dans un navigateur internet, ainsi que ``~/.ssh/id_rsa.pub`` dans un éditeur de texte. Il s'agit de la partie publique de votre clé SSH, il est donc sûr de la partager avec Launchpad. Copiez le contenu du fichier et collez-le dans la zone de texte sur la page Web affichant "Ajouter une clé SSH". Ensuite, cliquez sur "Importer la clé publique".

en: Configure your shell
fr: Configurez votre shell

en: Now save the file and either restart your terminal or run::
fr: Maintenant, sauvegardez le fichier et redémarrez votre terminal ou exécutez ::

en: (If you do not use the default shell, which is `bash`, please edit the configuration file for that shell accordingly.)
fr: (Si vous n'utilisez pas l'environnement par défaut, `bash`, veuillez modifier en conséquence le fichier de configuration pour cet environnement.)

en: Ubuntu Packaging Guide
fr: Guide d'empaquetage pour Ubuntu

en: Ubuntu is not only a free and open source operating system, its platform is also open and developed in a transparent fashion. The source code for every single component can be obtained easily and every single change to the Ubuntu platform can be reviewed.
fr: Ubuntu n'est pas seulement un système d'exploitation libre et open source, sa plate-forme est également ouverte et développée de manière transparente. Le code source de chaque composant s'obtient aisément et chaque modification de la plate-forme Ubuntu peut être examinée.

en: This means you can actively get involved in improving it and the community of Ubuntu platform developers is always interested in helping peers getting started.
fr: Cela signifie que vous pouvez activement participer à son amélioration et que la communauté des développeurs de la plate-forme Ubuntu se sent toujours concernée pour aider ses pairs à démarrer.

en: Ubuntu is also a community of great people who believe in free software and that it should be accessible for everyone. Its members are welcoming and want you to be involved as well. We want you to get involved, to ask questions, to make Ubuntu better together with us.
fr: Ubuntu est également une communauté de personnes formidables qui croient au logiciel libre afin qu'il reste accessible au plus grand nombre. Ses membres sont accueillants et souhaitent également votre participation. Nous souhaitons que vous vous impliquiez, posiez des questions, rendiez Ubuntu meilleur avec nous.

en: If you run into problems: don't panic! Check out the :doc:`communication article<./communication>` and you will find out how to most easily get in touch with other developers.
fr: Si vous rencontrez des problèmes : pas de panique ! Vérifiez l':doc:`article de communication<./communication>` et vous découvrirez comment rentrer plus facilement en contact avec d'autres développeurs.

en: The guide is split up into two sections:
fr: Le guide est divisé en deux sections :

en: A list of articles based on tasks, things you want to get done.
fr: Une liste d'articles basés sur les tâches ou les choses que vous souhaiteriez voir traitées.

en: A set of knowledge-base articles that dig deeper into specific bits of our tools and workflows.
fr: Un ensemble d'articles composant une base de connaissances plus approfondies sur des parties spécifiques de nos outils et nos flux de travail.

en: Knowledge Base
fr: Base de connaissances

en: Further Reading
fr: Lectures complémentaires

en: If you want to learn more about building Debian packages, here are some Debian resources you may find useful:
fr: Si vous souhaitez en savoir plus à propos de la construction de paquets Debian, voici quelques ressources Debian que vous trouverez utiles :

en: Introduction to Ubuntu Development
fr: Introduction au Développement d'Ubuntu

en: Ubuntu is made up of thousands of different components, written in many different programming languages. Every component -  be it a software library, a tool or a graphical application - is available as a source package. Source packages in most cases consist of two parts: the actual source code and metadata. Metadata includes the dependencies of the package, copyright and licensing information, and instructions on how to build the package. Once this source package is compiled, the build process provides binary packages, which are the .deb files users can install.
fr: Ubuntu est constitué de milliers de composants différents, écrits dans de multiples langages de programmation. Chaque composant - pouvant être une bibliothèque logicielle, un outil ou une application graphique - est disponible sous forme d'un paquet source. Dans la plupart des cas, les paquets sources se composent de deux parties : le code source réel et les métadonnées. Ces dernières comprennent les dépendances du paquet, les droits d'auteur et les informations de licence, ainsi que des instructions sur la façon de construire le paquet. Une fois ce paquet source compilé, le processus de construction fournit les paquets binaires, en d'autres termes, les fichiers .deb que les utilisateurs peuvent installer.

en: Ubuntu's development is very much dependent on the current stage of the release cycle. We release a new version of Ubuntu every six months, which is only possible because we have established strict freeze dates. With every freeze date that is reached developers are expected to make fewer, less intrusive changes. Feature Freeze is the first big freeze date after the first half of the cycle has passed. At this stage features must be largely implemented. The rest of the cycle is supposed to be focused on fixing bugs. After that the user interface, then the documentation, the kernel, etc. are frozen, then the beta release is put out which receives a lot of testing. From the beta release onwards, only critical bugs get fixed and a release candidate release is made and if it does not contain any serious problems, it becomes the final release.
fr: Le développement d'Ubuntu est très dépendant de la phase actuelle du cycle de sortie. Nous publions une nouvelle version d'Ubuntu tous les six mois, ce qui est rendu possible par l'établissement dates strictement figées. À chaque échéance atteinte, les développeurs doivent faire moins de modifications, ou les moins intrusives possibles. Le gel des fonctionnalités est la première grosse échéance après la première moitié du cycle. À ce stade, les nouvelles fonctionnalités doivent être largement appliquées. Le reste du cycle est censé se concentrer sur la correction des bogues. Ensuite, l'interface utilisateur, puis la documentation, le noyau, etc. sont gelés, puis la version bêta est mise en ligne pour recevoir un maximum de tests. À partir de la version bêta, seuls les bogues critiques sont corrigés, une version candidate est créée et lorsqu'elle ne contient pas de problèmes graves, elle devient la version finale.

en: Thousands of source packages, billions of lines of code, hundreds of contributors require a lot of communication and planning to maintain high standards of quality. At the beginning and in the middle of each release cycle we have the Ubuntu Developer Summit where developers and contributors come together to plan the features of the next releases. Every feature is discussed by its stakeholders and a specification is written that contains detailed information about its assumptions, implementation, the necessary changes in other places, how to test it and so on. This is all done in an open and transparent fashion, so you can participate remotely and listen to a videocast, chat with attendants and subscribe to changes of specifications, so you are always up to date.
fr: Des milliers de paquets sources, des milliards de lignes de code, des centaines de contributeurs exigent beaucoup de communication et de planification pour maintenir des normes élevées de qualité. Au début et au milieu de chaque cycle de version, nous avons le Sommet des Développeurs Ubuntu, où les développeurs et les contributeurs sont réunis pour planifier les fonctionnalités des prochaines versions. Chaque fonctionnalité est décrite par ses intervenants et un cahier des charges est écrit, contenant des informations détaillées sur ses hypothèses, sa mise en œuvre, les modifications nécessaires à d'autres endroits, la façon de la tester, etc. Tout cela est fait de manière ouverte et transparente, afin que vous puissiez participer à distance et regarder un flux vidéo, discuter avec les participants et adhérer aux modifications de spécifications, de sorte que vous soyez toujours informé.

en: Not every single change can be discussed in a meeting though, particularly because Ubuntu relies on changes that are done in other projects. That is why contributors to Ubuntu constantly stay in touch. Most teams or projects use dedicated mailing lists to avoid too much unrelated noise. For more immediate coordination, developers and contributors use Internet Relay Chat (IRC). All discussions are open and public.
fr: Chaque modification ne peut malgré tout pas être abordée lors d'une réunion, en particulier parce qu'Ubuntu repose sur des modifications effectuées dans d'autres projets. C'est pourquoi les contributeurs à Ubuntu restent constamment en contact. La plupart des équipes ou des projets utilisent des listes de diffusion dédiées en vue d'éviter trop de perturbations inutiles. Pour la coordination plus immédiate, les développeurs et les contributeurs utilisent Internet Relay Chat (IRC). Toutes les discussions y sont ouvertes et publiques.

en: Another important tool regarding communication is bug reports. Whenever a defect is found in a package or piece of infrastructure, a bug report is filed in Launchpad. All information is collected in that report and its importance, status and assignee updated when necessary. This makes it an effective tool to stay on top of bugs in a package or project and organise the workload.
fr: Un autre outil important en matière de communication est le rapport de bogue. Chaque fois qu'un défaut est décelé dans un paquet ou une partie de l'infrastructure, un rapport de bogue est déposé dans Launchpad. Toutes les informations sont recueillies dans ce rapport et l'importance, le statut et l'affectation du bogue sont mis à jour si nécessaire. Cela en fait un outil efficace pour surmonter les bogues dans un paquet ou un projet et pour organiser la charge de travail.

en: Most of the software available through Ubuntu is not written by Ubuntu developers themselves. Most of it is written by developers of other Open Source projects and then integrated into Ubuntu. These projects are called "Upstreams", because their source code flows into Ubuntu, where we "just" integrate it. The relationship to Upstreams is critically important to Ubuntu. It is not just code that Ubuntu gets from Upstreams, but it is also that Upstreams get users, bug reports and patches from Ubuntu (and other distributions).
fr: La plupart des logiciels disponibles dans Ubuntu ne sont pas écrits par les développeurs d'Ubuntu eux-mêmes. Une grande partie est écrite par les développeurs d'autres projets Open Source et ensuite intégrés dans Ubuntu. Ces projets sont appelés "amonts", parce que leurs codes sources se déversent dans Ubuntu, où nous faisons "juste" leur intégration. La relation avec les projets en amonts est extrêmement importante pour Ubuntu. Ce n'est pas uniquement le code qu'Ubuntu reçoit des projets en amont, ceux-ci profitent également des utilisateurs, des rapports de bogues et des correctifs de la part d'Ubuntu (et des autres distributions).

en: The most important Upstream for Ubuntu is Debian. Debian is the distribution that Ubuntu is based on and many of the design decisions regarding the packaging infrastructure are made there. Traditionally, Debian has always had dedicated maintainers for every single package or dedicated maintenance teams. In Ubuntu there are teams that have an interest in a subset of packages too, and naturally every developer has a special area of expertise, but participation (and upload rights) generally is open to everyone who demonstrates ability and willingness.
fr: L'amont le plus important pour Ubuntu est Debian. Debian est la distribution sur laquelle Ubuntu est basée et la plupart des décisions de conception relatives à l'infrastructure d'empaquetage sont prises là. Traditionnellement, Debian a toujours eu des responsables dédiés pour chaque paquet ou des équipes de maintenance dédiées. Dans Ubuntu, ce sont également des équipes qui s'intéressent à un sous-ensemble de paquets et, naturellement, chaque développeur possède un domaine d'expertise, mais la participation (et les droits de téléchargement) est généralement ouverte à tous ceux qui prouvent leur talent et leur volonté.

en: Getting a change into Ubuntu as a new contributor is not as daunting as it seems and can be a very rewarding experience. It is not only about learning something new and exciting, but also about sharing the solution and solving a problem for millions of users out there.
fr: Obtenir une modification dans Ubuntu en tant que nouveau collaborateur n'est pas aussi intimidant qu'il n'y paraît et peut même s'avérer une expérience très enrichissante. Il ne s'agit pas seulement d'apprendre quelque chose de nouveau et d'excitant, mais également de partager une solution et de résoudre un problème pour des millions d'utilisateurs.

en: Open Source Development happens in a distributed world with different goals and different areas of focus. For example there might be the case that a particular Upstream is interested in working on a new big feature while Ubuntu, because of the tight release schedule, is interested in shipping a solid version with just an additional bug fix. That is why we make use of "Distributed Development", where code is being worked on in various branches that are merged with each other after code reviews and sufficient discussion.
fr: Le développement Open Source intervient dans un monde partagé selon différents objectifs et différents domaines d'intérêt. Par exemple, cela pourrait être le cas d'un Amont particulier intéressé par le travail sur une nouvelle fonctionnalité importante, alors qu'Ubuntu, en raison de son échéancier serré de sortie, est intéressé par la fourniture d'une version robuste avec juste quelques corrections supplémentaires de bogues. C'est pourquoi nous utilisons le "Développement Distribué", où le code est en cours d'élaboration dans différentes branches qui sont fusionnées les unes avec les autres, après des révisions du code et des discussions adéquates.

en: In the example mentioned above it would make sense to ship Ubuntu with the existing version of the project, add the bugfix, get it into Upstream for their next release and ship that (if suitable) in the next Ubuntu release. It would be the best possible compromise and a situation where everybody wins.
fr: Dans l'exemple mentionné ci-dessus, il serait logique de fournir Ubuntu avec la version existante du projet, d'ajouter le correctif, de l'inclure à l'amont pour leur prochaine version et de fournir de nouveau le projet (s'il est convenable) avec la prochaine version d'Ubuntu. Ce serait le meilleur compromis possible et une situation gagnant-gagnant.

en: To fix a bug in Ubuntu, you would first get the source code for the package, then work on the fix, document it so it is easy to understand for other developers and users, then build the package to test it. After you have tested it, you can easily propose the change to be included in the current Ubuntu development release. A developer with upload rights will review it for you and then get it integrated into Ubuntu.
fr: Pour corriger un bogue dans Ubuntu, vous devrez d'abord obtenir le code source pour le paquet, puis travailler sur le correctif, le documenter pour qu'il soit simple à comprendre pour les autres développeurs et utilisateurs, puis construire le paquet pour le tester. Après l'avoir testé, vous pouvez aisément proposer que la modification soit incluse dans la version d'Ubuntu actuellement en développement. Un développeur ayant les droits de téléchargement l'examinera pour vous puis l'intégrera dans Ubuntu.

en: When trying to find a solution it is usually a good idea to check with Upstream and see if the problem (or a possible solution) is known already and, if not, do your best to make the solution a concerted effort.
fr: En cherchant une solution, il est généralement intelligent de vérifier avec l'amont et de voir si le problème (ou une solution possible) est connu et, dans le cas contraire, de faire de votre mieux pour que la solution soit un effort concerté.

en: Additional steps might involve getting the change backported to an older, still supported version of Ubuntu and forwarding it to Upstream.
fr: Des étapes supplémentaires pourraient induire le rétroportage des modifications vers une ancienne version d'Ubuntu encore prise en charge et leur transmission vers l'amont.

en: The most important requirements for success in Ubuntu development are: having a knack for "making things work again," not being afraid to read documentation and ask questions, being a team player and enjoying some detective work.
fr: Les pré-requis les plus importants pour réussir dans le développement d'Ubuntu sont les suivants : avoir un talent pour "faire que les choses fonctionnent de nouveau", ne pas avoir peur de lire la documentation et de poser des questions, jouer collectif et apprécier le travail de détective.

en: KDE Packaging
fr: Empaquetage pour KDE

en: Patching Policy
fr: Politique de correction

en: Kubuntu does not add patches to KDE programs unless they come from the upstream authors or submitted upstream with the expectation they will be merged soon or we have consulted the issue with the upstream authors.
fr: Kubuntu n'ajoute aucun correctif aux programmes KDE, sauf s'ils proviennent des auteurs de l'amont ou soumis à l'amont dans l'espoir qu'ils soient fusionnés au plus tôt, ou si nous avons consulté le problème avec les auteurs de l'amont.

en: Kubuntu does not change the branding of packages except where upstream expects this (such as the top left logo of the Kickoff menu) or to simplify (such as removing splash screens).
fr: Kubuntu ne modifie pas l'image de marque des paquets sauf si l'amont y compte (comme le logo en haut à gauche du menu Kickoff) ou si cela simplifie (comme la suppression des écrans de démarrage).

en: Debian packages include some additions to the basic Debhelper usage. These are kept in the ``pkg-kde-tools`` package.
fr: Les paquets Debian comprennent des ajouts à l'utilisation basique de Debhelper. Ceux-ci sont conservés dans le paquet ``pkg-kde-tools``.

en: Packages which use Debhelper 7 should add the ``--with=kde`` option. This will ensure the correct build flags are used and add options such as handling kdeinit stubs and translations::
fr: Les paquets utilisant Debhelper 7 doivent ajouter l'option ``--with=kde``. Cela permettra de s'assurer que les options correctes de compilation sont utilisées et ajoutera des options telles que la gestion des souches kdeinit et traductions ::

en: Some newer KDE packages use the ``dhmk`` system, an alternative to ``dh`` made by the Debian Qt/KDE team.  You can read about it in /usr/share/pkg-kde-tools/qt-kde-team/2/README.  Packages using this will ``include /usr/share/pkg-kde-tools/qt-kde-team/2/debian-qt-kde.mk`` instead of running ``dh``.
fr: Quelques récents paquets KDE utilisent le système ``dhmk``, une alternative à ``dh`` créé par l'équipe Debian Qt /KDE. Vous pouvez lire à ce sujet /usr/share/pkg-kde-tools/qt-kde-team/2/README. Les paquets utilisant ce système ``inclueront /usr/share/pkg-kde-tools/qt-kde-team/2/debian-qt-kde.mk`` au lieu d'éxecuter ``dh``.

en: Translations
fr: Traductions

en: Packages in main have their translations imported into Launchpad and exported from Launchpad into Ubuntu's language-packs.
fr: Les traductions des paquets principaux sont importées dans Launchpad et exportés de Launchpad vers Ubuntu dans les paquets de langues.

en: So any KDE package in main must generate translation templates, include or make available upstream translations and handle ``.desktop`` file translations.
fr: Ainsi, tout paquet KDE principal doit générer des modèles de traduction, inclure ou mettre à disposition les traductions de l'amont et gérer les traductions du fichier ``.desktop``.

en: To generate translation templates the package must include a ``Messages.sh`` file; complain to the upstream if it does not.  You can check it works by running ``extract-messages.sh`` which should produce one or more ``.pot`` files in ``po/``.  This will be done automatically during build if you use the ``--with=kde`` option to ``dh``.
fr: Pour générer des modèles de traduction le paquet doit comprendre un fichier ``Messages.sh`` ; demandez à l'amont, s'il n'existe pas. Vous pouvez vérifier qu'il fonctionne en exécutant ``extract-messages.sh`` qui devrait produire un ou plusieurs fichiers ``.pot``dans le dossier ``po/``. Cela se fera automatiquement lors de la compilation si vous utilisez l'option ``--with=kde`` de ``dh``.

en: If a package is moved from universe to main it will need to be re-uploaded before the translations get imported into Launchpad.
fr: Si un paquet est déplacé du dépôt « universe » au dépôt « main », il devra être téléchargé de nouveau avant que les traductions soient importées vers Launchpad.

en: ``.desktop`` files also need translations.  We patch KDELibs to read translations out of ``.po`` files which are pointed to by a line ``X-Ubuntu-Gettext-Domain=`` added to ``.desktop`` files at package build time.  A .pot file for each package is be generated at build time and .po files need to be downloaded from upstream and included in the package or in our language packs.  The list of .po files to be downloaded from KDE's repositories is in ``/usr/lib/kubuntu-desktop-i18n/desktop-template-list``.
fr: Les fichiers ``.desktop`` ont également besoin de traductions. Nous corrigeons KDElibs pour lire les traductions depuis les fichiers ``.po`` désignés par une ligne ``X-Ubuntu-Gettext-Domain=`` ajoutée aux fichiers ``.desktop`` au moment de la compilation du paquet. Un fichier .pot est généré pour chaque paquet lors de la compilation et les fichiers .po sont téléchargés depuis l'amont et inclus dans le paquet ou dans nos paquets de langue. La liste des fichiers .po à télécharger depuis les dépôts KDE se trouve dans ``/usr/lib/kubuntu-desktop-i18n/desktop-template-list``.

en: Library Symbols
fr: Bibliothèque de symboles

en: Shared Libraries
fr: Bibliothèques partagées

en: Shared libraries are compiled code which is intended to be shared among several different programs.  They are distributed as ``.so`` files in ``/usr/lib/``.
fr: Les bibliothèques partagées sont du code compilé destiné à être partagé entre plusieurs différents programmes. Ils sont distribués en tant que fichiers ``.so`` dans ``/usr/lib/``.

en: A library exports symbols which are the compiled versions of functions, classes and variables.  A library has a name called an SONAME which includes a version number.  This SONAME version does not necessarily match the public release version number.  A program gets compiled against a given SONAME version of the library.  If any of the symbols is removed or changes then the version number needs to be changed which forces any packages using that library to be recompiled against the new version.  Version numbers are usually set by upstream and we follow them in our binary package names called an ABI number, but sometimes upstreams do not use sensible version numbers and packagers have to keep separate version numbers.
fr: Une bibliothèque exporte des symboles qui sont les versions compilées de fonctions, de classes et de variables. Une bibliothèque possède ce qui s'appelle un SONAME comprenant un numéro de version. Cette version de SONAME ne correspond pas nécessairement au numéro de version publique. Un programme est compilé avec une version SONAME donnée de la bibliothèque. Si l'un des symboles est retiré ou modifié, alors le numéro de version doit être changé, ce qui oblige la recompilation de tous les paquets utilisant cette bibliothèque avec la nouvelle version. Les numéros de version sont généralement fixés par l'amont et nous les suivons dans nos noms de paquets binaires à l'aide d'un nombre ABI, mais parfois les amonts n'utilisent pas de numéros logiques de version et les empaqueteurs doivent conserver des numéros de version séparés.

en: Libraries are usually distributed by upstream as standalone releases. Sometimes they are distributed as part of a program.  In this case they can be included in the binary package along with the program (this is called bundling) if you do not expect any other programs to use the library, more often they should be split out into separate binary packages.
fr: Les bibliothèques sont généralement distribuées par l'amont sous forme de versions autonomes. Parfois, elles sont distribuées comme partie d'un programme. Dans ce cas, elles peuvent être incluses dans le paquet binaire avec le programme (c'est ce qu'on appelle le regroupement) lorsqu'il n'est pas prévu que d'autres programmes utilisent la bibliothèque. Le plus souvent, elles sont divisées en plusieurs paquets binaires séparés.

en: The libraries themselves are put into a binary package named ``libfoo1`` where ``foo`` is the name of the library and ``1`` is the version from the SONAME. Development files from the package, such as header files, needed to compile programs against the library are put into a package called ``libfoo-dev``.
fr: Les bibliothèques elles-mêmes sont mises dans un paquet binaire nommé ``libfoo1`` où ``foo`` est le nom de la bibliothèque et ``1`` la version de SONAME. Les fichiers de développement issus du paquet, tels que les fichiers d'en-tête, nécessaires pour compiler des programmes avec la bibliothèque sont placés dans un paquet appelé ``libfoo-dev``.

en: An Example
fr: Un exemple

en: We will use libnova as an example::
fr: Nous allons utiliser libnova comme exemple ::

en: To find the SONAME of the library run::
fr: Pour trouver le SONAME de la bibliothèque, lancez ::

en: The SONAME is ``libnova-0.12.so.2``, which matches the file name (usually the case but not always). Here upstream has put the upstream version number as part of the SONAME and given it an ABI version of ``2``.  Library package names should follow the SONAME of the library they contain. The library binary package is called ``libnova-0.12-2`` where ``libnova-0.12`` is the name of the library and ``2`` is our ABI number.
fr: Le SONAME est ``libnova-0.12.so.2``, qui correspond au nom du fichier (généralement c'est le cas, mais pas toujours). Ici, l'amont a mis le numéro de version comme partie du SONAME et lui a donné ``2`` comme version d'ABI. Les noms de paquets de bibliothèque devraient suivre le SONAME de la bibliothèque les contenant. Le paquet binaire de bibliothèque s'appelle ``libnova-0.12-2``, où ``libnova-0.12`` est le nom de la bibliothèque et ``2`` est notre ABI.

en: If upstream makes incompatible changes to their library they will have to reversion their SONAME and we will have to rename our library.  Any other packages using our library package will need to recompiled against the new version, this is called a transition and can take some effort. Hopefully our ABI number will continue to match upstream's SONAME but sometimes they introduce incompatibilities without changing their version number and we will need to change ours.
fr: Si l'amont apporte des modifications incompatibles avec leur bibliothèque, il devra revoir la version de SONAME et nous devrons renommer notre bibliothèque. Tous les autres paquets utilisant notre paquet de  bibliothèque devront être recompilés à la nouvelle version, c'est ce qu'on appelle une transition et peut demander un certain travail. Heureusement, notre nombre ABI continuera à correspondre au SONAME des amonts, mais parfois ils introduisent des incompatibilités sans changer leurs numéros de version et nous devrons changer les nôtres.

en: Looking in debian/libnova-0.12-2.install we see it includes two files::
fr: En regardant dans debian/libnova-0.12-2.install, nous voyons qu'il comprend deux fichiers ::

en: The last one is the actual library, complete with minor and point version number.  The first one is a symlink which points to the actual library.  The symlink is what programs using the library will look for, the running programs do not care about the minor version number.
fr: Le dernier est la bibliothèque réelle, se terminant par un numéro de version mineur et un point. Le premier est un lien symbolique pointant vers la bibliothèque réelle. Le lien symbolique est ce que les programmes utilisant la bibliothèque rechercheront, les programmes en cours d'exécution ne se souciant pas du numéro de version mineur.

en: ``libnova-dev.install`` includes all the files needed to compile a program with this library.  Header files, a config binary, the ``.la`` libtool file and ``libnova.so`` which is another symlink pointing at the library, programs compiling against the library do not care about the major version number (although the binary they compile into will).
fr: ``Libnova-dev.install`` inclut tous les fichiers nécessaires pour compiler un programme utilisant cette bibliothèque. Les fichiers d'en-tête, un binaire de configuration, le fichier ``.la`` d'utilitaires bibliothèque et ``libnova.so`` qui est un autre lien symbolique pointant vers la bibliothèque, les programmes compilant avec cette bibliothèque ne se souciant pas du numéro de version majeur (même si le binaire qu'ils compilent le feront).

en: Static Libraries
fr: Les bibliothèques statiques

en: The -dev package also ships ``usr/lib/libnova.a``.  This is a static library, an alternative to the shared library.  Any program compiled against the static library will include the code directory into itself.  This gets round worrying about binary compatibility of the library.  However it also means that any bugs, including security issues, will not be updated along with the library until the program is recompiled.  For this reason programs using static libraries are discouraged.
fr: Les paquets -dev délivrent aussi ``usr/lib/libnova.a``. Il s'agit d'une bibliothèque statique, une alternative à la bibliothèque partagée. Tout programme compilé avec la bibliothèque statique comprendra le répertoire du code en lui-même. Cela contourne le souci de la compatibilité binaire de la bibliothèque. Mais cela signifie aussi que tous les bogues, y compris les problèmes de sécurité, ne seront pas mis à jour avec la bibliothèque jusqu'à ce que le programme soit recompilé. Pour cette raison, l'usage de programmes utilisant des bibliothèques statiques est déconseillé.

en: Symbol Files
fr: Les fichiers de symboles

en: When a package builds against a library the ``shlibs`` mechanism will add a package dependency on that library.  This is why most programs will have ``Depends: ${shlibs:Depends}`` in ``debian/control``.  That gets replaced with the library dependencies at build time.  However shlibs can only make it depend on the major ABI version number, ``2`` in our libnova example, so if new symbols get added in libnova 2.1 a program using these symbols could still be installed against libnova ABI 2.0 which would then crash.
fr: Quand un paquet est construit à partir d'une bibliothèque, le mécanisme ``shlibs`` ajoute une dépendance de paquet sur cette bibliothèque. C'est pourquoi de nombreux programmes auront ``Depends: ${shlibs:Depends}`` dans ``debian/control``. Ceci est remplacé par les dépendances de bibliothèque à la compilation. Cependant shlibs peut seulement le faire dépendre du numéro de version majeure ABI, ``2`` dans notre exemple libnova. Si de nouveaux symboles sont ajoutés à libnova 2.1, un programme utilisant ces symboles pourrait toujours être installé avec libnova ABI 2.0, ce qui provoquerait son plantage.

en: To make the library dependencies more precise we keep ``.symbols`` files that list all the symbols in a library and the version they appeared in.
fr: Pour rendre les dépendances de bibliothèques plus précises, nous gardons les fichiers ``.symbols`` qui répertorient tous les symboles d'une bibliothèque et la version à laquelle ils sont apparus.

en: libnova has no symbols file so we can create one.  Start by compiling the package::
fr: libnova n'a pas de fichier de symboles, nous pouvons donc en créer un. Commencez par la compilation du paquet ::

en: The ``-nc`` will cause it to finish at the end of compilation without removing the built files.  Change to the build and run ``dpkg-gensymbols`` for the library package::
fr: Le ``-nc`` terminera la compilation sans supprimer les fichiers de construction. Modifiez le fichier compilé et exécutez ``dpkg-gensymbols`` pour le paquet de bibliothèque ::

en: This makes a diff file which you can self apply::
fr: Cela crée un fichier diff que vous pouvez rendre automatiquement applicable ::

en: Which will create a file named similar to ``dpkg-gensymbolsnY_WWI`` that lists all the symbols.  It also lists the current package version.  We can remove the packaging version from that listed in the symbols file because new symbols are not generally added by new packaging versions, but by the upstream developers::
fr: Ce qui va créer un fichier nommé de manière similaire à ``dpkg-gensymbolsnY_WWI`` listant tous les symboles. Il répertorie également la version actuelle du paquet. Nous pouvons supprimer la version d'empaquetage de celles indiquées dans le fichier de symboles car de nouveaux symboles ne sont généralement pas ajoutés par de nouvelles versions d'empaquetage, mais par les développeurs de l'amont ::

en: Now move the file into its location, commit and do a test build::
fr: Maintenant, déplacez le fichier à sa place, soumettez et faites un test de compilation ::

en: If it successfully compiles the symbols file is correct.  With the next upstream version of libnova you would run dpkg-gensymbols again and it will give a diff to update the symbols file.
fr: Si la compilation s'achève avec succès, le fichier de symboles est correct. Avec la prochaine version amont de libnova, vous devrez exécuter dpkg-gensymbols à nouveau et cela vous donnera un fichier diff pour mettre à jour le fichier de symboles.

en: C++ Library Symbols Files
fr: Les fichiers C++ de la bibliothèque de symboles

en: Packaging New Software
fr: L'empaquetage de nouveaux logiciels

en: While there are thousands of packages in the Ubuntu archive, there are still a lot nobody has gotten to yet. If there is an exciting new piece of software that you feel needs wider exposure, maybe you want to try your hand at creating a package for Ubuntu or a PPA_. This guide will take you through the steps of packaging new software.
fr: Bien qu'il existe des milliers de paquets dans l'archive d'Ubuntu, il y en reste encore beaucoup que personne n'a pu obtenir jusqu'à maintenant. S'il existe une nouvelle et passionnante partie de logiciel pour laquelle vous sentez le besoin d'une exposition plus large, peut-être voudriez-vous vous essayer à la création d'un paquet pour Ubuntu ou d'un PPA_. Ce guide vous mènera à travers les étapes d'empaquetage de nouveaux logiciels.

en: You will want to read the :doc:`Getting Set Up<./getting-set-up>` article first in order to prepare your development environment.
fr: Vous aurez envie en premier lieu de lire l'article :doc:`Mise en route<./getting-set-up>` afin de préparer votre environnement de développement.

en: Checking the Program
fr: Vérification du programme

en: The first stage in packaging is to get the released tar from upstream (we call the authors of applications "upstream") and check that it compiles and runs.
fr: La première étape de l'empaquetage est d'obtenir le fichier .tar issu de l'amont (nous appelons les auteurs d'applications « l'amont ») et de vérifier qu'il se compile et s'exécute.

en: This guide will take you through packaging a simple application called GNU Hello which has been posted on GNU.org_.
fr: Ce guide vous mènera à travers l'empaquetage d'une application simple, appelée GNU Bonjour, postée sur GNU.org_.

en: This application uses the autoconf build system so we want to run ``./configure`` to prepare for compilation.
fr: Cette application utilise le système de construction autoconf, nous exécuterons donc ``./configure`` pour préparer la compilation.

en: This will check for the required build dependencies. As ``hello`` is a simple example, ``build-essential`` should provide everything we need. For more complex programs, the command will fail if you do not have the needed libraries and development files. Install the needed packages and repeat until the command runs successfully.::
fr: Cela vérifiera les dépendances de construction nécessaires. Comme ``bonjour`` est un exemple simple, ``build-essential`` doit fournir tout ce dont nous avons besoin. Pour les programmes plus complexes, la commande échouera si vous n'avez pas les bibliothèques et les fichiers de développement nécessaires. Installez les paquets nécessaires et recommencez jusqu'à ce que la commande s'exécute avec succès.::

en: Now you can compile the source::
fr: Maintenant vous pouvez compiler la source ::

en: If compilation completes successfully you can install and run the program::
fr: Si la compilation se termine avec succès, vous pouvez installer et exécuter le programme ::

en: Starting a Package
fr: Commencer un paquet

en: When it asks what type of package type ``s`` for single binary. This will import the code into a branch and add the ``debian/`` packaging directory.  Have a look at the contents.  Most of the files it adds are only needed for specialist packages (such as Emacs modules) so you can start by removing the optional example files::
fr: Lorsqu'il vous est demandé le type de paquet, entrez ``s`` pour binaire unique. Ceci importera le code dans une branche et ajoutera le répertoire d'empaquetage ``debian/``. Jetez un œil sur son contenu. La plupart des fichiers ajoutés ne sont nécessaires que pour les paquets spécialisés (tels que les modules d'Emacs) de sorte que vous pouvez commencer par supprimer les fichiers optionnels d'exemple ::

en: You should now customise each of the files.
fr: Vous devriez maintenant personnaliser chacun des fichiers.

en: Much of the package building work is done by a series of scripts called ``debhelper``.  The exact behaviour of ``debhelper`` changes with new major versions, the compat file instructs ``debhelper`` which version to act as.  You will generally want to set this to the most recent version which is ``9``.
fr: Le gros du travail de construction de paquet est réalisé par une série de scripts appelée ``debhelper``. Le comportement exact de ``debhelper`` change avec les nouvelles versions majeures, le fichier compat indique à ``debhelper`` à quelle version se conformer. Vous souhaiterez généralement régler ce paramètre à la version la plus récente qui est ``9``.

en: ``control`` contains all the metadata of the package.  The first paragraph describes the source package. The second and following paragraphs describe the binary packages to be built.  We will need to add the packages needed to compile the application to ``Build-Depends:``. For ``hello``, make sure that it includes at least::
fr: ``control`` contient toutes les métadonnées du paquet. Le premier paragraphe décrit le paquet source. Les paragraphes suivants décrivent les paquets binaires à construire. Nous aurons besoin d'ajouter à ``Build-Depends:`` les paquets nécessaires pour compiler l'application. Pour ``bonjour``, assurez-vous qu'il comprend au moins ::

en: You will also need to fill in a description of the program in the ``Description:`` field.
fr: Vous devrez également remplir une description du programme dans le ``champ Description:``.

en: ``copyright`` needs to be filled in to follow the licence of the upstream source.  According to the hello/COPYING file this is GNU GPL 3 or later.
fr: Le ``copyright`` doit être rempli pour suivre la licence de la source en amont. Selon le fichier bonjour/COPYING, il s'agit de la licence GNU GPL 3 ou ultérieure.

en: ``docs`` contains any upstream documentation files you think should be included in the final package.
fr: ``docs`` contient les fichiers de documentation de l'amont qui, selon vous, devraient être inclus dans le paquet final.

en: ``README.source`` and ``README.Debian`` are only needed if your package has any non-standard features, we don't so you can delete them.
fr: ``README.source`` et ``README.Debian`` ne sont nécessaires que si votre paquet possède une caractéristique non standard, ce qui n'est pas le cas donc vous pouvez les supprimer.

en: ``source/format`` can be left as is, this describes the version format of the source package and should be ``3.0 (quilt)``.
fr: ``source/format`` peut être laissé tel quel, il décrit le format de version du paquet source et devrait être ``3.0 (quilt)``.

en: ``rules`` is the most complex file.  This is a Makefile which compiles the code and turns it into a binary package.  Fortunately most of the work is automatically done these days by ``debhelper 7`` so the universal ``%`` Makefile target just runs the ``dh`` script which will run everything needed.
fr: ``rules`` est le fichier le plus complexe. Il s'agit d'un Makefile qui compile le code et le transforme en un paquet binaire. Heureusement, le gros du travail se fait de nos jours automatiquement à l'aide de  ``debhelper 7`` de telle sorte que la cible universelle ``%`` du Makefile lance uniquement le script ``dh`` qui exécute toutes les opérations nécessaires.

en: All of these file are explained in more detail in the :doc:`overview of the debian directory<./debian-dir-overview>` article.
fr: Tous ces fichiers sont expliqués plus en détail dans l'article :doc:`aperçu du répertoire Debian<./debian-dir-overview>`.

en: Finally commit the code to your packaging branch::
fr: Enfin, soumettez le code à votre branche d'empaquetage ::

en: Building the package
fr: Construisez le paquet

en: Now we need to check that our packaging successfully compiles the package and builds the .deb binary package::
fr: Maintenant, nous devons vérifier que notre empaquetage compile le paquet correctement et construit le paquet binaire .deb ::

en: ``bzr builddeb`` is a command to build the package in its current location. The ``-us -uc`` tell it there is no need to GPG sign the package.  The result will be placed in ``..``.
fr: ``bzr builddeb`` est une commande pour construire le paquet dans son emplacement actuel. Le ``-us -uc`` indique que GPG n'a pas besoin de signer le paquet. Le résultat sera placé dans le dossier ``..``.

en: You can view the contents of the package with::
fr: Vous pouvez afficher le contenu du paquet avec ::

en: Next Steps
fr: Étapes suivantes

en: After making a fix to the packaging you can rebuild using ``-nc`` "no clean" without having to build from scratch::
fr: Après avoir établi un correctif pour l'empaquetage, vous pouvez le reconstruire en utilisant ``-nc`` pour « no clean » afin d'éviter d'avoir à le reconstruire à partir de zéro ::

en: Having checked that the package builds locally you should ensure it builds on a clean system using ``pbuilder``. Since we are going to upload to a PPA (Personal Package Archive) shortly, this upload will need to be *signed* to allow Launchpad to verify that the upload comes from you (you can tell the upload will be signed because the ``-us`` and ``-uc`` flags are not passed to ``bzr builddeb`` like they were before). For signing to work you need to have set up GPG. If you haven't set up ``pbuilder-dist`` or GPG yet, :doc:`do so now<./getting-set-up>`::
fr: Après avoir vérifié que le paquet est construit localement, vous devez vous assurer qu'il peut se compiler sur un système propre à l'aide de ``pbuilder``. Puisque nous allons bientôt l'ajouter à un PPA (Personal Package Archives), ce téléchargement doit être *signé* pour permettre à Launchpad de vérifier que le téléchargement émane de vous (vous pouvez dire que le téléchargement sera signé car les options ``-us`` et ``-uc`` ne sont pas transmises à ``bzr builddeb`` comme auparavant). Pour que la signature fonctionne, vous devez avoir configuré GPG. Si vous n'avez pas encore configuré ``pbuilder-dist`` ou GPG, :doc:`faites le maintenant<./getting-set-up>` ::

en: When you are happy with your package you will want others to review it.  You can upload the branch to Launchpad for review::
fr: Lorsque vous serez satisfait de votre paquet, vous souhaiterez en obtenir la relecture par d'autres. Vous pouvez télécharger la branche vers Launchpad pour la relecture ::

en: Uploading it to a PPA will ensure it builds and give an easy way for you and others to test the binary packages.  You will need to set up a PPA in Launchpad and then upload with ``dput``::
fr: Le télécharger vers un PPA assurera qu'il se construit et donnera un moyen aisé pour vous et les autres de tester les paquets binaires. Vous avez besoin de configurer un PPA dans Launchpad puis de télécharger avec ``dput`` ::

en: Submitting for inclusion
fr: Soumettez pour inclusion

en: There are a number of paths that a package can take to enter Ubuntu. In most cases, going through Debian first can be the best path. This way ensures that your package will reach the largest number of users as it will be available in not just Debian and Ubuntu but all of their derivatives as well. Here are some useful links for submitting new packages to Debian:
fr: Il existe nombre de chemins que peut emprunter un paquet pour entrer dans Ubuntu. Dans la plupart des cas, passer par Debian en premier peut s'avérer la meilleure voie. Cette façon vous assure que votre paquet atteindra le plus grand nombre d'utilisateurs, car il sera disponible non seulement dans Debian et Ubuntu, mais également dans l'ensemble de leurs dérivés. Voici quelques liens utiles pour soumettre de nouveaux paquets à Debian :

en: Screenshots
fr: Captures d'écran

en: Once you have uploaded a package to debian, you should add screenshots to allow propective users to see what the program is like. These should be uploaded to http://screenshots.debian.net/upload .
fr: Une fois que vous avez téléversé un paquet vers debian, vous devez ajouter des captures d'écran pour permettre aux utilisateurs potentiels de voir à quoi le programme ressemble. Elles doivent être téléversées sur http://screenshots.debian.net/upload.

en: Patches to Packages
fr: Correctifs aux paquets

en: Sometimes, Ubuntu package maintainers have to change the upstream source code in order to make it work properly on Ubuntu.  Examples include, patches to upstream that haven't yet made it into a released version, or changes to the upstream's build system needed only for building it on Ubuntu.  We could change the upstream source code directly, but doing this makes it more difficult to remove the patches later when upstream has incorporated them, or extract the change to submit to the upstream project.  Instead, we keep these changes as separate patches, in the form of diff files.
fr: Parfois, les mainteneurs de paquets d'Ubuntu doivent modifier le code source en amont afin de le faire fonctionner correctement avec Ubuntu. Les exemples incluent les correctifs vers l'amont qui n'ont pas encore été repris dans une version finale, ou les modifications du système de compilation de l'amont uniquement nécessaires pour la compilation avec Ubuntu. Nous pourrions modifier le code source en amont directement (mais en faisant cela il devient plus difficile d'enlever les correctifs plus tard, lorsque l'amont les a intégré) ou extraire les modifications pour les soumettre au projet de l'amont. Au lieu de ça, nous gardons ces modifications comme des correctifs séparés, sous la forme de fichiers diff.

en: There are a number of different ways of handling patches in Debian packages, fortunately we are standardizing on one system, `Quilt`_, which is now used by most packages.
fr: Il existe de nombreuses façons différentes de gérer les correctifs dans les paquets Debian. Heureusement, nous sommes en cours de standardisation sur un système, `Quilt`_, qui est désormais utilisé par la majorité des paquets.

en: The patches are kept in ``debian/patches``.  This package has one patch ``kubuntu_01_fix_qmax_on_armel.diff`` to fix a compile failure on ARM.  The patch has been given a name to describe what it does, a number to keep the patches in order (two patches can overlap if they change the same file) and in this case the Kubuntu team adds their own prefix to show the patch comes from them rather than from Debian.
fr: Les correctifs sont conservés dans ``debian/patches``. Ce paquet a un correctif ``kubuntu_01_fix_qmax_on_armel.diff`` pour résoudre un échec de compilation sur ARM. Le correctif a un nom explicite pour décrire ce qu'il fait, un numéro pour garder les correctifs dans l'ordre (deux correctifs peuvent se chevaucher s'ils modifient le même fichier) et dans ce cas l'équipe de Kubuntu ajoute son propre préfixe pour montrer que le correctif provient d'eux plutôt que de Debian.

en: The order of patches to apply is kept in ``debian/patches/series``.
fr: L'ordre des correctifs à appliquer est conservé dans ``debian/patches/series``.

en: Patches with Quilt
fr: Les correctifs avec Quilt

en: Before working with Quilt you need to tell it where to find the patches.  Add this to your ``~/.bashrc``::
fr: Avant de travailler avec Quilt, vous devrez lui dire où trouver les correctifs. Ajoutez ceci à votre ``~/.bashrc`` ::

en: And source the file to apply the new export::
fr: Et renseignez sur quel fichier appliquer le nouvel export ::

en: By default all patches are applied already to UDD checkouts or downloaded packages.  You can check this with::
fr: Par défaut, tous les correctifs sont déjà appliqués sur les vérifications UDD ou les paquets téléchargés. Vous pouvez le vérifier avec ::

en: If you wanted to remove the patch you would run ``pop``::
fr: Si vous voulez supprimer le correctif, vous lancerez ``pop`` ::

en: And to apply a patch you use ``push``::
fr: Et pour appliquer un correctif, vous utiliserez ``push`` ::

en: Adding a New Patch
fr: Ajout d'un nouveau correctif

en: To add a new patch you need to tell Quilt to create a new patch, tell it which files that patch should change, edit the files then refresh the patch::
fr: Pour ajouter un nouveau correctif, vous devez dire à Quilt de créer un nouveau correctif, lui dire quels sont les fichiers que le correctif doit modifier, éditer les fichiers et ensuite actualiser le correctif ::

en: The ``quilt add`` step is important, if you forget it the files will not end up in the patch.
fr: L'étape ``quilt add`` est importante, si vous l'oubliez les fichiers ne se retrouveront pas dans le correctif.

en: The change will now be in ``debian/patches/kubuntu_02_program_description.diff`` and the ``series`` file will have had the new patch added to it.  You should add the new file to the packaging::
fr: La modification sera désormais dans ``debian/patches/kubuntu_02_program_description.diff`` et le dossier ``series`` sera complété par le nouveau correctif. Vous devez ajouter le nouveau fichier à l'empaquetage ::

en: Quilt keeps its metadata in the ``.pc/`` directory, so currently you need to add that to the packaging too.  This should be improved in future.
fr: Quilt conserve ses métadonnées dans le répertoire ``.pc/``, vous devez donc actuellement l'ajouter également à l'empaquetage. Cela devrait être amélioré à l'avenir.

en: As a general rule you should be careful adding patches to programs unless they come from upstream, there is often a good reason why that change has not already been made.  The above example changes a user interface string for example, so it would break all translations.  If in doubt, do ask the upstream author before adding a patch.
fr: Comme règle générale, vous devez rester prudent dans l'ajout de correctifs aux programmes à moins qu'ils ne proviennent de l'amont, car il existe souvent une bonne raison pour que la modification n'ait pas encore été faite. L'exemple ci-dessus modifie une chaîne de l'interface par exemple, elle pourrait donc briser toutes les traductions. En cas de doute, n'hésitez pas à consulter l'auteur de l'amont avant d'ajouter un patch.

en: Patch Headers
fr: En-têtes de correctifs

en: We recommend that you tag every patch with DEP-3_ headers by putting them at the top of patch file. Here are some headers that you can use:
fr: Nous vous recommandons de marquer chaque correctif avec des en-têtes DEP-3_, en les plaçant au début du fichier de correctif. Voici quelques en-têtes que vous pouvez utiliser :

en: Who wrote the patch (i.e. "Jane Doe <packager@example.com>").
fr: Qui a écrit le correctif (par exemple, « Jane Doe <packager@example.com> »).

en: Where this patch comes from (i.e. "upstream"), when *Author* is not present.
fr: D'où provient ce correctif (par exemple « de l'amont »), lorsque *Auteur* n'est pas renseigné.

en: A link to Launchpad bug, a short form is preferred (like *https://bugs.launchpad.net/bugs/XXXXXXX*). If there are also bugs in upstream or Debian bugtrackers, add *Bug* or *Bug-Debian* headers.
fr: Un lien vers le traceur de bogues Launchpad, un format court étant préférable (comme *https://bugs.launchpad.net/bugs/XXXXXXX*). S'il existe également des bogues dans les traceurs de bogues de l'amont ou de Debian, ajoutez les en-têtes *Bug* ou *Bug-Debian*.

en: Whether the patch was forwarded upstream. Either "yes", "no" or "not-needed".
fr: Si le correctif a été transmis à l'amont. Soit « yes », « no » ou « not-needed ».

en: Date of the last revision (in form "YYYY-MM-DD").
fr: Date de la dernière révision (au format "AAAA-MM-JJ").

en: Upgrading to New Upstream Versions
fr: Mise à niveau vers les nouvelles versions de l'amont

en: To upgrade to the new version, you can use ``bzr merge-upstream`` command::
fr: Pour mettre à niveau vers la nouvelle version, vous pouvez utiliser la commande ``bzr merge-upstream`` ::

en: When you run this command, all patches will be unapplied, because they can become out of date. They might need to be refreshed to match the new upstream source or they might need to be removed altogether. To check for problems, apply the patches one at a time::
fr: Lorsque vous lancez cette commande, tous les correctifs ne seront pas appliqués, car ils peuvent devenir obsolètes. Ils pourraient avoir besoin d'être actualisés, pour correspondre à la nouvelle source de l'amont, ou entièrement supprimés. Pour vérifier les problèmes, appliquez les correctifs un par un ::

en: If it can be reverse-applied this means the patch has been applied already by upstream, so we can delete the patch::
fr: S'il peut être rétro-appliqué, cela signifie que le correctif a déjà été appliqué par l'amont, nous pouvons donc le supprimer ::

en: Then carry on::
fr: Ensuite, continuons ::

en: It is a good idea to run refresh, this will update the patch relative to the changed upstream source::
fr: C'est une bonne idée de lancer l'actualisation, cela va mettre à jour le correctif relatif à la source modifiée par l'amont ::

en: Then commit as usual::
fr: Ensuite, soumettez comme d'habitude ::

en: Making A Package Use Quilt
fr: Réaliser un Paquet avec Quilt

en: Modern packages use Quilt by default, it is built into the packaging format.  Check in ``debian/source/format`` to ensure it says ``3.0 (quilt)``.
fr: Les paquets modernes utilisent Quilt par défaut, il est intégré dans le format d'empaquetage. Vérifiez dans ``debian/source/format`` que ce dernier est ``3.0 (quilt)``.

en: Older packages using source format 1.0 will need to explicitly use Quilt, usually by including a makefile into ``debian/rules``.
fr: Les paquets plus anciens utilisant le format source 1.0 vous obligent à utiliser Quilt explicitement, généralement en incluant un fichier makefile dans ``debian/rules``.

en: Configuring Quilt
fr: Configurer Quilt

en: You can use ``~/.quiltrc`` file to configure quilt. Here are some options that can be useful for using quilt with debian/packages:
fr: Vous pouvez utiliser le fichier ``~/.quiltrc`` pour configurer quilt. Voici quelques options pouvant s'avérer utiles pour l'utilisation de quilt avec debian/packages :

en: Other Patch Systems
fr: Autres systèmes de correctifs

en: Other patch systems used by packages include ``dpatch`` and ``cdbs simple-patchsys``, these work similarly to Quilt by keeping patches in ``debian/patches`` but have different commands to apply, un-apply or create patches. You can find out which patch system is used by a package by using the ``what-patch`` command (from the ``ubuntu-dev-tools`` package). You can use ``edit-patch``, shown in :ref:`previous chapters <working-on-a-fix>`, as a reliable way to work with all systems.
fr: Les autres systèmes de correctifs utilisés par les paquets incluent ``dpatch`` et ``cdbs simple-patchsys``, qui travaillent de manière similaire à Quilt en conservant les correctifs dans ``debian/patches``, mais possèdent des commandes différentes pour rendre applicables, non-applicables ou créer des correctifs. Vous pouvez savoir quel système de correctif est utilisé par un paquet en utilisant la commande ``what-patch`` (issue du paquet ``ubuntu-dev-tools``). Vous pouvez utiliser ``edit-patch``, illustré dans un :ref:`chapitre précédent<working-on-a-fix>`, comme un moyen fiable pour travailler avec tous les systèmes de correctifs.

en: In even older packages changes will be included directly to sources and kept in the ``diff.gz`` source file.  This makes it hard to upgrade to new upstream versions or differentiate between patches and is best avoided.
fr: Dans des paquets encore plus anciens, les modifications sont incluses directement aux sources et conservées dans le fichier source ``diff.gz``. Cela rend difficile leur mise à niveau vers les nouvelles versions de l'amont ou la différenciation des correctifs. Il vaut mieux l'éviter.

en: Do not change a package's patch system without discussing it with the Debian maintainer or relevant Ubuntu team.  If there is no existing patch system then feel free to add Quilt.
fr: Ne modifiez pas un système de correctif d'un paquet sans en discuter avec le responsable Debian ou l'équipe Ubuntu adéquate. S'il n'existe pas de système de correctif existant, alors n'hésitez pas à ajouter Quilt.

en: Security and Stable Release Updates
fr: Mises à jour de sécurité et de version stable

en: Fixing a Security Bug in Ubuntu
fr: Correction d'un bogue de sécurité dans Ubuntu

en: Fixing security bugs in Ubuntu is not really any different than :doc:`fixing a regular bug in Ubuntu<./fixing-a-bug>`, and it is assumed that you are familiar with patching normal bugs. To demonstrate where things are different, we will be updating the dbus package in Ubuntu 12.04 LTS (Precise Pangolin) for a security update.
fr: La résolution de bogues de sécurité dans Ubuntu n'est pas vraiment différente de :doc:` la résolution d'un bogue normal dans Ubuntu<./fixing-a-bug>`, et nous présumons que vous êtes familier avec la correction de bogues normaux. Pour montrer où les choses diffèrent, nous mettrons à jour le paquet dbus dans Ubuntu 12.04 LTS (Precise Pangolin) pour une mise à jour de sécurité.

en: Obtaining the source
fr: L'obtention de la source

en: In this example, we already know we want to fix the dbus package in Ubuntu 12.04 LTS (Precise Pangolin). So first you need to determine the version of the package you want to download. We can use the ``rmadison`` to help with this::
fr: Dans cet exemple, nous savons déjà que nous souhaitons solutionner le paquet dbus dans Ubuntu 12.04 LTS (Precise Pangolin). Ainsi en premier lieu, vous devez déterminer la version du paquet que vous souhaiter télécharger. Nous pouvons utiliser le ``rmadison`` pour y parvenir ::

en: Typically you will want to choose the highest version for the release you want to patch that is not in -proposed or -backports. Since we are updating Precise's dbus, you'll download 1.4.18-1ubuntu1.4 from precise-updates::
fr: Typiquement, vous souhaiterez choisir la plus récente des versions pour la corriger qui n'est ni dans -proposed ni dans -backports. Puisque nous sommes en train de mettre à jour le dbus de Precise, vous téléchargerez 1.4.18-1ubuntu1.4 depuis precise-updates ::

en: Patching the source
fr: Correction de la source

en: To create your patch using ``edit-patch``::
fr: Pour créer votre correctif en utilisant ``edit-patch`` ::

en: This will apply the existing patches and put the packaging in a temporary directory. Now edit the files needed to fix the vulnerability.  Often upstream will have provided a patch so you can apply that patch::
fr: Cela appliquera les correctifs existants, et placera l'empaquetage dans un répertoire temporaire. Ensuite, éditez les fichiers nécessaires pour corriger la vulnérabilité. Souvent, l'amont a fourni un correctif afin que vous puissiez l'appliquer ::

en: After making the necessary changes, you just hit Ctrl-D or type exit to leave the temporary shell.
fr: Après avoir effectué les modifications nécessaires, vous appuyez simplement sur Ctrl-D ou tapez exit pour quitter l'environnement temporaire.

en: Formatting the changelog and patches
fr: Formatage du changelog et des correctifs

en: After applying your patches you will want to update the changelog. The ``dch`` command is used to edit the ``debian/changelog`` file and ``edit-patch`` will launch ``dch`` automatically after un-applying all the patches. If you are not using ``edit-patch``, you can launch ``dch -i`` manually. Unlike with regular patches, you should use the following format (note the distribution name uses precise-security since this is a security update for Precise) for security updates::
fr: Après avoir appliqué vos correctifs vous devrez mettre à jour le changelog. La commande ``dch`` est utilisée pour modifier le fichier ``debian/changelog`` et ``edit-patch`` lancera automatiquement ``dch`` après ne pas avoir appliqué tous les correctifs. Si vous n'utilisez pas ``edit-patch``, vous pouvez lancer manuellement ``dch -i``. Contrairement aux correctifs normaux, vous devrez utiliser le format suivant (notez que le nom de distribution utilise precise-security puisqu'il s'agit d'un mise à jour de sécurité pour Precise) pour les mises à jour de sécurité ::

en: Update your patch to use the appropriate patch tags. Your patch should have at a minimum the Origin, Description and Bug-Ubuntu tags. For example, edit debian/patches/99-fix-a-vulnerability.patch to have something like::
fr: Mettez à jour votre correctif pour utiliser les balises de correctifs appropriées. Votre correctif devrait avoir au minimum les balises Origine, Description et Bug-Ubuntu. Par exemple, éditer debian/patches/99-fix-a-vulnerability.patch pour obtenir quelque chose comme ::

en: Multiple vulnerabilities can be fixed in the same security upload; just be sure to use different patches for different vulnerabilities.
fr: De multiples vulnérabilités peuvent être corrigées dans le même téléchargement de sécurité ; il suffit de s'assurer d'utiliser des correctifs différents pour les différentes vulnérabilités.

en: Test and Submit your work
fr: Testez et soumettez votre travail

en: At this point the process is the same as for :doc:`fixing a regular bug in Ubuntu<./fixing-a-bug>`. Specifically, you will want to:
fr: À ce stade, le processus est le même que pour :doc:`corriger un bogue normal dans Ubuntu<./fixing-a-bug>`. Plus précisément, vous devrez :

en: Build your package and verify that it compiles without error and without any added compiler warnings
fr: Créer votre paquet et vérifier qu'il se compile sans erreur et sans aucun avertissement additionnel du compilateur

en: Upgrade to the new version of the package from the previous version
fr: Mettre à niveau vers la nouvelle version du paquet à partir de la version précédente

en: Test that the new package fixes the vulnerability and does not introduce any regressions
fr: Vérifier que le nouveau paquet corrige la vulnérabilité et n'introduit pas de régression

en: Submit your work via a Launchpad merge proposal and file a Launchpad bug being sure to mark the bug as a security bug and to subscribe ``ubuntu-security-sponsors``
fr: Soumettre votre travail par le biais d'une proposition de fusion sur Launchpad et déposer un rapport de bogue Launchpad en vous assurant tout d'abord de marquer le bogue comme étant un bogue de sécurité et ensuite de vous inscrire à ``ubuntu-security-sponsors``

en: If the security vulnerability is not yet public then do not file a merge proposal and ensure you mark the bug as private.
fr: Si le problème de sécurité n'est pas encore public alors ne déposez pas une proposition de fusion mais assurez-vous de marquer le bogue comme privé.

en: The filed bug should include a Test Case, i.e. a comment which clearly shows how to recreate the bug by running the old version then how to ensure the bug no longer exists in the new version.
fr: Le bogue déposé doit inclure un cas de test, c'est à dire un commentaire qui explique clairement comment recréer le bogue en exécutant l'ancienne version, puis comment s'assurer que le bogue n'existe plus dans la nouvelle version.

en: The bug report should also confirm that the issue is fixed in Ubuntu versions newer than the one with the proposed fix (in the above example newer than Precise).  If the issue is not fixed in newer Ubuntu versions you should prepare updates for those versions too.
fr: Le rapport de bogue doit également confirmer que le problème est corrigé dans les versions Ubuntu ultérieures à celle proposée à la correction (dans l'exemple ci-dessus, plus récentes que Précise). Si le problème n'est pas corrigé dans les nouvelles versions, vous devrez préparer les mises à jour pour ces versions également.

en: Stable Release Updates
fr: Mises à jour vers Version Stable

en: We also allow updates to releases where a package has a high impact bug such as a severe regression from a previous release or a bug which could cause data loss.  Due to the potential for such updates to themselves introduce bugs we only allow this where the change can be easily understood and verified.
fr: Nous permettons aussi les mises à jour de versions où un paquet bogué a un lourd impact, comme une régression sévère depuis une version antérieure, ou un bogue qui cause des pertes de données. En raison de la capacité de telles mises à jour à introduire elles-mêmes des bogues, nous ne les autorisons que lorsque les modifications peuvent être facilement comprises et vérifiées.

en: The process for Stable Release Updates is just the same as the process for security bugs except you should subscribe ``ubuntu-sru`` to the bug.
fr: Le processus des Mises à jour de version stable est exactement le même que celui des bogues de sécurité, hormis que vous devez vous inscrire à ``ubuntu-sru`` pour le bogue.

en: The update will go into the ``proposed`` archive (for example ``precise-proposed``) where it will need to be checked that it fixes the problem and does not introduce new problems.  After a week without reported problems it can be moved to ``updates``.
fr: La mise à jour ira dans l'archive ``proposed`` (par exemple ``precise-proposed``) où il sera vérifié qu'elle corrige le problème et n'introduit pas de nouveaux problèmes. Après une semaine sans problème rapporté, elle peut être déplacée vers ``updates``.
