% This file was generated with po4a. Translate the source file.
%
\documentclass[10pt,final]{beamer}
\mode<presentation> \usetheme{debian}

\usepackage{debiantutorial.fr} \usepackage[french]{babel}
\frenchbsetup{og=«,fg=»}

\hypersetup{bookmarks}
\title{Tutoriel : la construction de paquets Debian}
\author[]{Lucas
Nussbaum\\{\small\texttt{packaging-tutorial@packages.debian.org}}\\[0.5em]Traduction
française de\\ Cédric\ Boutillier, Jean-Philippe\ Mengual\\et l'équipe
francophone de traduction}

\date{\footnotesize version 0.29 -- 2021-11-03} 

\begin{document}


\frame{\titlepage}

\begin{frame}{À propos de ce tutoriel}
  \begin{itemize}
  \item Objectif : \textbf{présenter ce que vous devez absolument savoir sur la
construction de paquets Debian}
    \begin{itemize}
      \hbr
    \item Modifier des paquets existants
      \hbr
    \item Créer vos propres paquets
	    \hbr
    \item Interagir avec la communauté Debian
      \hbr
    \item Devenir un utilisateur chevronné de Debian
    \end{itemize}
    \br
  \item Il couvre les points les plus importants mais n'est pas complet
    \begin{itemize}
    \item Vous devrez lire plus de documentation
    \end{itemize}
    \br
  \item L'essentiel s'applique aussi aux distributions dérivées de Debian
    \begin{itemize}
      \hbr
    \item en particulier à Ubuntu
    \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}{Plan}
  \tableofcontents[hideallsubsections]
\end{frame}

\section{Introduction}

\subsection{Debian}

\begin{frame}{Debian}
	\begin{itemize}
		\item \textbf{Distribution GNU/Linux}
			\br
		\item 1\iere distribution majeure développée « ouvertement dans l'esprit GNU »
			\br
		\item \textbf{Non commerciale}, fruit de la collaboration de plus de 1~000
bénévoles
			\br
		\item 3 caractéristiques principales :
			\begin{itemize}
				\item \textbf{Qualité} -- culture de l'excellence technique\\ {\small\sl Nous
publions quand c'est prêt}
					\hbr
				\item \textbf{Liberté} -- développeurs et utilisateurs adhèrent au \textsl{Contrat
social}\\ Promotion de la culture du logiciel libre depuis 1993
					\hbr
				\item \textbf{Indépendance} -- pas d'entreprise (unique) pour chapeauter Debian\\ 
et processus décisionnel ouvert (\textsl{volontariat} + \textsl{démocratie})
			\end{itemize}
                        \br
                \item \textbf{Amateur} dans le bon sens du terme : \og fait avec amour \fg
	\end{itemize}
\end{frame}

\subsection{Paquets Debian}
\begin{frame}{Paquets Debian}
\begin{itemize}
\item Fichiers \textbf{.deb} (paquets binaires)
	\br
\item Moyen puissant et pratique pour distribuer des logiciels aux utilisateurs 
	\br
\item Un des deux formats de paquets les plus courants avec RPM
	\br
\item Universel :
	\begin{itemize}
		\item 30~000 paquets binaires dans Debian\\ $\rightarrow$ la plupart des logiciels
libres sont empaquetés dans Debian !
			\hbr
		\item 12 portages (architectures), dont 2 non Linux (Hurd et kFreeBSD)
			\hbr
		\item Utilisé aussi par 120 distributions dérivées de Debian
	\end{itemize}
\end{itemize}
\end{frame}


\subsection{Le format de paquet Deb}

\begin{frame}[fragile=singleslide]{Le format de paquet Deb}
  \begin{itemize}
  \item Fichier \texttt{.deb} : une archive \texttt{ar}
    \begin{lstlisting}[basicstyle=\ttfamily\footnotesize]
$ ar tv wget_1.12-2.1_i386.deb
rw-r--r-- 0/0      4 Sep  5 15:43 2010 debian-binary
rw-r--r-- 0/0   2403 Sep  5 15:43 2010 control.tar.gz
rw-r--r-- 0/0 751613 Sep  5 15:43 2010 data.tar.gz
    \end{lstlisting} \begin{itemize}
    \item \texttt{debian-binary} : version du format de fichier .deb, «
\texttt{2.0\textbackslash{}n} »
    \item \texttt{control.tar.gz} : métadonnées sur le paquet\\ {\small
\texttt{\textbf{control}, md5sums, (pre|post)(rm|inst), triggers,
shlibs}\ldots}
    \item \texttt{data.tar.gz} : fichiers de données du paquet
    \end{itemize}
    \br
  \item Vous pourriez créer vos fichiers \texttt{.deb} à la main\\ {\footnotesize
\url{http://tldp.org/HOWTO/html\_single/Debian-Binary-Package-Building-HOWTO/}}
    \br
  \item Mais la plupart des gens ne font pas comme ça
  \end{itemize}
  \br
  \centerline{\textbf{Ce tutoriel : création de paquets Debian à la manière Debian}}
\end{frame}

\subsection{Outils dont vous avez besoin}
\begin{frame}{Outils dont vous avez besoin}
  \begin{itemize}
  \item Un système Debian (ou Ubuntu) (avec accès superutilisateur)
    \br
  \item Quelques paquets :
    \begin{itemize}
    \item \textbf{build-essential} : dépend de paquets supposés disponibles sur la
machine du développeur (inutile de les indiquer dans le champ de contrôle
\texttt{Build-Depends} de votre paquet)
      \begin{itemize}
      \item dépend aussi de \textbf{dpkg-dev}, contenant les outils de base spécifiques
à Debian pour créer des paquets
      \end{itemize}
      \hbr
    \item \textbf{devscripts} : contient de nombreux scripts utiles pour les
responsables Debian
    \end{itemize}
  \end{itemize}

  \br
  Beaucoup d'autres outils seront aussi mentionnés plus tard, tels que
\textbf{debhelper}, \textbf{cdbs}, \textbf{quilt}, \textbf{pbuilder},
\textbf{sbuild}, \textbf{lintian}, \textbf{svn-buildpackage},
\textbf{git-buildpackage}\ldots\\ Installez-les au besoin.
\end{frame}

\subsection{Processus général de la construction de paquets}
\begin{frame}{Processus général de la construction de paquets}
  \begin{center}
    \begin{tikzpicture}[
      node1/.style={shape=rectangle,draw=rouge,fill=debianbackgroundblue,thick},
      arr/.style={very thick}, command/.style={text=rouge,font=\ttfamily}, ]
      
      \node[node1] (www) at (0, 0) {Web}; \node[node1] (us) at (2.5, 0) {sources
amont}; \node[node1] (da) at (-2.5, 0) {miroir Debian}; \node[node1] (sp) at
(0, -2) {paquet source}; \draw[arr,<-,dashed,thick] (sp) -- (2.5,-2)
node[right=0cm,text width=3.1cm,text centered,font=\small\sl] {là où la
plupart du travail manuel est fait}; \node[node1] (bin) at (0, -4) {un ou
plusieurs paquets binaires}; \draw[arr,<-,dashed,thick] (bin) -- (3.5,-4)
node[right,text centered,font=\small\ttfamily\sl] {.deb\normalfont};
\draw[arr,->] (us) -- (sp) node[pos=0.5,right,command] {dh\_make};
\draw[arr,->] (da) -- (sp) node[pos=0.5,left,command] {apt-get source};
\draw[arr,->] (www) -- (sp) node[pos=0.5,left,command] {dget}; \draw[arr,->]
(sp) -- (bin) node[pos=0.5,right,text width=6cm] {\textttc{debuild}
(construire et tester avec \textttc{lintian}) ou
\textttc{dpkg-buildpackage}}; \draw[arr,->] (bin) -- (1,-6)
node[pos=0.5,right] {installer (\textttc{debi})}; \draw[transparent] (bin)
-- (-1,-6) node[pos=0.5,left,opaque] {envoyer (\textttc{dput})};
\draw[arr,->,rounded corners] (bin) -- (-1,-6) -- (-4.5,-6) -- (-4.5,0) --
(da); \useasboundingbox (-4,-6) rectangle (6,0); \end{tikzpicture}
  \end{center}
\end{frame}

\subsection{Reconstruction de dash}
\begin{frame}{Exemple : reconstruction de dash}
\begin{enumerate}
\item Installez les paquets nécessaires à la construction de dash, ainsi que
devscripts \\ {\texttt{apt-get build-dep dash}\\ (nécessite des lignes
\texttt{deb-src} dans \texttt{/etc/apt/sources.list})}\\ {\texttt{apt-get
install -{}-no-install-recommends devscripts fakeroot}}
  \hbr
\item Créez un répertoire de travail et entrez-y\\ \texttt{mkdir
/tmp/debian-tutorial ; cd /tmp/debian-tutorial}
  \hbr
\item Récupérez le paquet source de \texttt{dash}\\ \texttt{apt-get source dash}\\ 
{\small (Il faut pour cela avoir des lignes \texttt{deb-src} dans votre
\texttt{/etc/apt/sources.list})}
  \hbr
\item Construisez le paquet\\ {\texttt{cd dash-*\\ debuild -us -uc}}
~~~(\texttt{-us -uc} désactive la signature du paquet avec GPG)

  \hbr
\item Vérifiez le résultat
	\begin{itemize}
		\item  Il y a de nouveaux fichiers \texttt{.deb} dans le répertoire parent
	\end{itemize}
    \hbr
\item Regardez le répertoire \texttt{debian/}
	\begin{itemize}
		\item C'est là que se fait le travail de construction du paquet
	\end{itemize}
\end{enumerate}
\end{frame}

\section{Création des paquets source}
\subsection{Notions de base sur les paquets source}
\begin{frame}{Paquet source}
  \begin{itemize}
  \item Un paquet source peut produire plusieurs paquets binaires\\ {\small Le
paquet source \texttt{\bfseries libtar} produit les paquets binaires
\texttt{\bfseries libtar0} et \texttt{\bfseries libtar-dev}} \hbr
  \item Deux types de paquets : (en cas de doute, utilisez « non natif »)
    \begin{itemize}
      \small
    \item natif : normalement pour les logiciels spécifiques à Debian (\textsl{dpkg},
\textsl{apt}\ldots)
    \item non natif : logiciels développés hors de Debian
    \end{itemize}
    \hbr
  \item Fichier principal : \texttt{.dsc} (métadonnées)
    \hbr
  \item Autres fichiers selon la version du format source
    \begin{itemize}
    \item 1.0 ou 3.0 (natif) : \texttt{paquet\_version.tar.gz}
      \hbr
    \item 1.0 (non natif) :
      \begin{itemize}
      \item \texttt{paquet\_ver.orig.tar.gz} : sources amont
      \item \texttt{paquet\_debver.diff.gz} : correctif avec des modifications
spécifiques à Debian
      \end{itemize}
      \hbr
    \item 3.0 (quilt) :
      \begin{itemize}
      \item \texttt{paquet\_ver.orig.tar.gz} : sources amont
      \item \texttt{paquet\_debver.debian.tar.gz} : archive tar avec les modifications
de Debian
      \end{itemize}
    \end{itemize}
  \end{itemize}
  \hbr
  (Consultez \texttt{dpkg-source(1)} pour les détails exacts.)
\end{frame}

\begin{frame}[fragile=singleslide]{Exemple de paquet source (wget\_1.12-2.1.dsc)}
  \begin{lstlisting}[basicstyle=\ttfamily\small]
Format: 3.0 (quilt)
Source: wget
Binary: wget
Architecture: any
Version: 1.12-2.1
Maintainer: Noel Kothe <noel@debian.org>
Homepage: http://www.gnu.org/software/wget/
Standards-Version: 3.8.4
Build-Depends: debhelper (>> 5.0.0), gettext, texinfo,
 libssl-dev (>= 0.9.8), dpatch, info2man
Checksums-Sha1: 
 50d4ed2441e67[..]1ee0e94248 2464747 wget_1.12.orig.tar.gz
 d4c1c8bbe431d[..]dd7cef3611 48308 wget_1.12-2.1.debian.tar.gz
Checksums-Sha256: 
 7578ed0974e12[..]dcba65b572 2464747 wget_1.12.orig.tar.gz
 1e9b0c4c00eae[..]89c402ad78 48308 wget_1.12-2.1.debian.tar.gz
Files: 
 141461b9c04e4[..]9d1f2abf83 2464747 wget_1.12.orig.tar.gz
 e93123c934e3c[..]2f380278c2 48308 wget_1.12-2.1.debian.tar.gz
\end{lstlisting}
\end{frame}

\subsection{Récupération des paquets source}
\begin{frame}{Récupération d'un paquet source existant}
  \begin{itemize}
  \item À partir de l'archive Debian :
    \begin{itemize}
    \item \texttt{apt-get source \textsl{paquet}}
    \item \texttt{apt-get source \textsl{paquet=version}}
    \item \texttt{apt-get source \textsl{paquet/distribution}}
    \end{itemize}
    (Vous avez besoin de lignes \texttt{deb-src} dans \texttt{sources.list})
    \br
  \item Depuis Internet :
    \begin{itemize}
    \item \texttt{dget \textsl{url-vers.dsc}}
    \item \texttt{dget
http://snapshot.debian.org/archive/debian-archive/\\20090802T004153Z/debian/dists/bo/main/source/web/\\ 
wget\_1.4.4-6.dsc}\\ (\href{http://snapshot.debian.org/}{\ttfamily
snapshot.d.o} fournit tous les paquets de Debian depuis 2005)
    \end{itemize}
    \br
  \item Depuis le gestionnaire de versions (déclaré) :
    \begin{itemize}
    \item \texttt{debcheckout \textsl{paquet}}
    \end{itemize}
    \br
  \item Une fois téléchargé, dépaquetez-le avec \texttt{dpkg-source -x
\textsl{fichier.dsc}}
  \end{itemize}
\end{frame}

\subsection{Création d'un paquet source de base}
\begin{frame}{Création d'un paquet source de base}
  \begin{itemize}
  \item Téléchargez l'archive des sources amont\\ (\textsl{sources amont} = celles
fournies par les développeurs du logiciel)
    \hbr
  \item Renommez-la en
\texttt{<\textsl{paquet\_source}>\_<\textsl{version\_amont}>.orig.tar.gz}\\ 
(exemple : \texttt{simgrid\_3.6.orig.tar.gz})
    \hbr
  \item Décompressez-la
    \hbr
  \item Renommez le répertoire en
\texttt{<\textsl{paquet\_source}>-<\textsl{version\_amont}>}\\ (exemple :
\texttt{simgrid-3.6})
    \hbr
  \item \texttt{cd <\textsl{paquet\_source}>-<\textsl{version\_amont}> \&\&
dh\_make} (du paquet \textbf{dh-make})
    \hbr
  \item Il existe des alternatives à \texttt{dh\_make} pour des types de paquets
spécifiques : \textbf{dh-make-perl}, \textbf{dh-make-php}\ldots \hbr
  \item Un répertoire \texttt{debian/} est créé, contenant de nombreux fichiers
  \end{itemize}
\end{frame}

\subsection{Fichiers dans debian/}
\begin{frame}{Fichiers dans debian/}
  L'empaquetage ne doit se faire qu'en modifiant les fichiers de
\texttt{debian/}
  \hbr
  \begin{itemize}
  \item Fichiers principaux :
    \begin{itemize}
    \item \textbf{control} -- métadonnées sur le paquet (dépendances, etc.)
    \item \textbf{rules} -- indique la manière de construire le paquet
    \item \textbf{copyright} -- informations de copyright du paquet
    \item \textbf{changelog} -- journal des modifications du paquet Debian
    \end{itemize}
    \hbr
  \item Autres fichiers :
    \begin{itemize}
    \item compat
    \item watch
    \item configuration de dh\_install* ({\small *.dirs, *.docs, *.manpages\ldots})
    \item scripts du responsable ({\small *.postinst, *.prerm\ldots})
    \item source/format
    \item patches/ -- si vous avez besoin de modifier les sources amont
    \end{itemize}
    \hbr
  \item Plusieurs fichiers ont un format basé sur la RFC 822 (en-têtes de courriel)
  \end{itemize}
\end{frame}

\begin{frame}[fragile=singleslide]{debian/changelog}
  \begin{itemize}
  \item Liste les modifications dans la construction du paquet Debian
  \item Donne la version actuelle du paquet
  \begin{center}
    \begin{tikzpicture}
	    \draw (0,0) node[above right] {\large 1.2.1.1-5}; \draw
[decorate,decoration={brace}] (2,0) -- (1.45,0) node[at start,below,text
width=1.6cm,text centered] {\small Révision Debian}; \draw
[decorate,decoration={brace}] (1.4,0) -- (0,0) node[midway,below,text
width=1.6cm,text centered] { \small Version amont};
\end{tikzpicture}
\end{center}


	  \item Édité à la main ou avec \textttc{dch}
  \begin{itemize}
	  \item Pour créer une entrée pour une nouvelle version : \textttc{dch -i}
  \end{itemize}
  \item Format spécial pour clôturer des bogues Debian ou Ubuntu\\ Debian :
\texttt{Closes:~\#595268}; Ubuntu : \texttt{LP:~\#616929}
  \item Installé en tant que
\texttt{/usr/share/doc/\textit{paquet}/changelog.Debian.gz}
  \end{itemize}
  \seprule
  \begin{lstlisting}[basicstyle=\ttfamily\footnotesize]
mpich2 (1.2.1.1-5) unstable; urgency=low

  * Use /usr/bin/python instead of /usr/bin/python2.5. Allow
    to drop dependency on python2.5.  Closes: #595268
  * Make /usr/bin/mpdroot setuid. This is the default after
    the installation of mpich2 from source, too. LP: #616929
    + Add corresponding lintian override.

 -- Lucas Nussbaum <lucas@debian.org>  Wed, 15 Sep 2010 18:13:44 +0200
\end{lstlisting}
\end{frame}

\begin{frame}[fragile=singleslide]{debian/control}
  \hbr
  \begin{itemize}
  \item Métadonnées du paquet
    \begin{itemize}
    \item pour le paquet source lui-même
    \item pour chaque paquet binaire construit à partir de ce paquet source
    \end{itemize}
    \hbr
  \item Nom du paquet, section, priorité, responsable, \textit{uploaders},
dépendances de construction, dépendances, description, page d'accueil\ldots \hbr
  \item Documentation : la Charte Debian, chapitre 5\\ 
\url{https://www.debian.org/doc/debian-policy/ch-controlfields.html}
  \end{itemize}
  \seprule
\begin{lstlisting}[basicstyle=\ttfamily\footnotesize]
Source: wget
Section: web
Priority: important
Maintainer: Noel Kothe <noel@debian.org>
Build-Depends: debhelper (>> 5.0.0), gettext, texinfo,
 libssl-dev (>= 0.9.8), dpatch, info2man
Standards-Version: 3.8.4
Homepage: http://www.gnu.org/software/wget/

Package: wget
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: retrieves files from the web
 Wget is a network utility to retrieve files from the Web
\end{lstlisting}
\end{frame}

\begin{frame}{Architecture: « all » ou « any »}
  Deux types de paquets binaires :
  \hbr
  \begin{itemize}
  \item Paquets ayant un contenu différent selon l'architecture Debian
    \begin{itemize}
    \item Exemple : programme C
    \item \texttt{Architecture:~any} dans \texttt{debian/control}
      \begin{itemize}
      \item Si ça ne fonctionne que sur certaines architectures :\\ 
\texttt{Architecture:~amd64 i386 ia64 hurd-i386}
      \end{itemize}
    \item buildd.debian.org : construit les autres architectures à l'envoi
    \item Nommés \texttt{\textsl{paquet}\_\textsl{version}\_\textsl{architecture}.deb}
    \end{itemize}
    \br
  \item Paquets ayant le même contenu sur toutes les architectures
    \begin{itemize}
    \item Exemple : bibliothèque Perl
    \item \texttt{Architecture:~all} dans \texttt{debian/control}
    \item Nommé \texttt{\textsl{paquet}\_\textsl{version}\_\textbf{all}.deb}
    \end{itemize}
  \end{itemize}
  \br
  Un même paquet source peut engendrer à la fois des paquets binaires
\texttt{Architecture:~any} et \texttt{Architecture:~all}
\end{frame}

\begin{frame}[fragile=singleslide]{debian/rules}
  \hbr
  \begin{itemize}
  \item Makefile
    \br
  \item Interface utilisée pour construire des paquets Debian
    \br
  \item Documenté dans la Charte Debian, chapitre 4.8\\ {\small
\url{https://www.debian.org/doc/debian-policy/ch-source\#s-debianrules}}
    \br
  \item Cibles requises\ :
    \begin{itemize}
    \item \texttt{build, build-arch, build-indep} : doit effectuer toute la
configuration et la compilation
      \hbr
    \item \texttt{binary, binary-arch, binary-indep} : créent les paquets binaires
      \begin{itemize}
      \item \texttt{dpkg-buildpackage} appellera \texttt{binary} pour construire tous
les paquets ou \texttt{binary-arch} pour ne construire que les paquets
\texttt{Architecture:~any}
      \end{itemize}
      \hbr
    \item \texttt{clean} : nettoie le répertoire des sources
    \end{itemize}
  \end{itemize}
\end{frame}

\subsection{Assistants d'empaquetage}
\begin{frame}{Assistants d'empaquetage -- debhelper}
  \begin{itemize}
  \item Vous pourriez écrire du code shell dans le fichier \texttt{debian/rules}
  \item Mieux : utilisez un \textsl{assistant d'empaquetage} \\(déjà le cas pour la
plupart des paquets)
  \item Le plus populaire : \textbf{debhelper} (utilisé par 98~\% des paquets)
  \item Objectifs :
    \begin{itemize}
    \item Centraliser les tâches courantes dans des outils normalisés qui seront
utilisés par tous les paquets
    \item Corriger d'un coup des bogues de construction pour tous les paquets
    \end{itemize}{\footnotesize dh\_installdirs, dh\_installchangelogs, dh\_installdocs,
dh\_install, dh\_installdebconf, dh\_installinit, dh\_link, dh\_strip,
dh\_compress, dh\_fixperms, dh\_perl, dh\_makeshlibs, dh\_installdeb,
dh\_shlibdeps, dh\_gencontrol, dh\_md5sums, dh\_builddeb, \ldots}
    \begin{itemize}
    \item Appelé depuis \texttt{debian/rules}
    \item Configurable avec des paramètres ou des fichiers dans \texttt{debian/}
    \end{itemize}{\footnotesize \ttfamily dirs, \textsl{paquet}.docs,
\textsl{paquet}.examples, \textsl{paquet}.install,
\textsl{paquet}.manpages\ldots} \hbr
  \item Assistants tiers pour certains types de paquets : \textbf{python-support},
\textbf{dh\_ocaml}\ldots \hbr
  \item \texttt{debian/compat}: version de compatibilité de Debhelper
	  \begin{itemize}
		  \item Définit le comportement précis de dh\_*
		  \item Nouvelle syntaxe : \texttt{Build-Depends: debhelper-compat (= 13)}
	  \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}[fragile=singleslide]{debian/rules en utilisant debhelper (1/2)}
  \begin{lstlisting}[basicstyle=\ttfamily\footnotesize,escapeinside=\{\}]
#!/usr/bin/make -f

# D{\'e}commentez cette ligne pour passer en mode bavard.
#export DH_VERBOSE=1

build: 
        $(MAKE)
        #docbook-to-man debian/packagename.sgml > packagename.1

clean: 
        dh_testdir
        dh_testroot
        rm -f build-stamp configure-stamp
        $(MAKE) clean
        dh_clean 

install: build
        dh_testdir
        dh_testroot
        dh_clean -k 
        dh_installdirs
        # Ajoutez ici des commandes pour installer
        # le paquet dans debian/packagename.
        $(MAKE) DESTDIR=$(CURDIR)/debian/packagename install
\end{lstlisting}
\end{frame}

\begin{frame}[fragile=singleslide]{debian/rules en utilisant debhelper (2/2)}
  \begin{lstlisting}[basicstyle=\ttfamily\footnotesize,escapeinside=\{\}]

# Construire ici les fichiers non sp{\'e}cifiques {\`a} une architecture.
binary-indep: build install

# Construire ici les fichiers sp{\'e}cifiques {\`a} une architecture.
binary-arch: build install
        dh_testdir
        dh_testroot
        dh_installchangelogs 
        dh_installdocs
        dh_installexamples
        dh_install
        dh_installman
        dh_link
        dh_strip
        dh_compress
        dh_fixperms
        dh_installdeb
        dh_shlibdeps
        dh_gencontrol
        dh_md5sums
        dh_builddeb

binary: binary-indep binary-arch
.PHONY: build clean binary-indep binary-arch binary install configure
\end{lstlisting}
\end{frame}

\begin{frame}[fragile=singleslide]{CDBS}
  \hbr
  \begin{itemize}
  \item Avec debhelper, restent beaucoup de redondances entre les paquets
    \hbr
  \item Assistants de second niveau incluant des fonctionnalités courantes
    \begin{itemize}
    \item p. ex. construction avec \texttt{./configure \&\& make \&\& make install}
    \end{itemize}
    \hbr
  \item CDBS :
    \begin{itemize}
    \item Introduit en 2005, basé sur la magie évoluée de \textsl{GNU make}
    \item Documentation : \texttt{/usr/share/doc/cdbs/}
    \item Gestion de Perl, Python, Ruby, GNOME, KDE, Java, Haskell\ldots
    \item Mais certaines personnes le détestent :
      \begin{itemize}
      \item Il est parfois difficile à personnaliser : « \textsl{enchevêtrement complexe
de makefiles et de variables d'environnement} »
      \item Plus lent que l'utilisation seule de debhelper (beaucoup d'appels inutiles à
\texttt{dh\_*})
      \end{itemize}
    \end{itemize}
  \end{itemize}
  \seprule
      \begin{lstlisting}[basicstyle=\ttfamily\footnotesize,escapeinside=\{\}]
#!/usr/bin/make -f
include /usr/share/cdbs/1/rules/debhelper.mk
include /usr/share/cdbs/1/class/autotools.mk

# ajouter une action apr{\`e}s la construction
build/monpaquet::
    /bin/bash debian/scripts/toto.sh
      \end{lstlisting}
\end{frame}

\begin{frame}[fragile=singleslide]{Dh (aussi appelé Debhelper 7, ou dh7)}
  \begin{itemize}
  \item Introduit en 2008, avec l'objectif de remplacer CDBS
    \hbr
  \item Commande \textbf{dh} qui appelle \texttt{dh\_*}
    \hbr
  \item Fichier \textsl{debian/rules} simple, ne contenant que les redéfinitions
    \hbr
  \item Plus facile à personnaliser que CDBS
    \hbr
  \item Doc : pages de man (\texttt{debhelper(7)}, \texttt{dh(1)}) et présentation à
DebConf9\\ 
\url{http://kitenet.net/~joey/talks/debhelper/debhelper-slides.pdf}
  \end{itemize}
  \seprule
    \begin{lstlisting}[basicstyle=\ttfamily\footnotesize]
#!/usr/bin/make -f
%:
    dh $@

override_dh_auto_configure:
     dh_auto_configure -- --with-kitchen-sink

override_dh_auto_build:
     make world

    \end{lstlisting}
\end{frame}

\begin{frame}{debhelper classique vs CDBS vs dh}
  \hbr
  \begin{itemize}
  \item Parts de marché :\\ debhelper classique : 15~\% \hskip 1em CDBS : 15~\%
\hskip 1em dh : 68~\%
    \hbr
  \item Lequel apprendre ?
    \begin{itemize}
    \item Probablement un peu de chaque
    \item Vous devez connaître debhelper pour utiliser dh et CDBS
    \item Vous pourriez avoir à modifier des paquets CDBS
    \end{itemize}
    \hbr
  \item Lequel utiliser pour un nouveau paquet ?
    \begin{itemize}
	    \item \textbf{dh} (seule solution de plus en plus utilisée)
	    \item Voir \url{https://trends.debian.net/\#build-systems}
    \end{itemize}
  \end{itemize}
  
  \hbr


\end{frame}

\section{Construire et tester les paquets}
\subsection{Construire les paquets}
\begin{frame}{Construire les paquets}
  \begin{itemize}
  \item \textttc{apt-get build-dep monpaquet}\\ Installer les \textsl{dépendances de
construction} (pour un paquet dans Debian)\\ Ou \textttc{mk-build-deps -ir}
(pour un paquet pas encore envoyé dans Debian)
    
    \br
  \item \textttc{debuild} : construire, tester avec \texttt{lintian}, signer avec
GPG
    \br
  \item Vous pouvez aussi faire appel directement à \textttc{dpkg-buildpackage}
    \begin{itemize}
    \item En général, avec \texttt{dpkg-buildpackage -us -uc}
    \end{itemize}
    \br
  \item Il vaut mieux construire les paquets dans un environnement minimal
    \begin{itemize}
    \item \textttc{pbuilder} -- assistant pour la construction de paquets dans un
\textsl{chroot}\\ Bonne documentation :
\url{https://wiki.ubuntu.com/PbuilderHowto}\\ (optimisation :
\textttc{cowbuilder} \textttc{ccache} \textttc{distcc})
      \hbr
    \item \textttc{schroot} et \textttc{sbuild} : utilisé sur les démons de
construction Debian\\ (pas aussi simple que \texttt{pbuilder}, mais permet
des copies LVM\\ voir :
\url{https://help.ubuntu.com/community/SbuildLVMHowto} )
    \end{itemize}
    \br
  \item Crée les fichiers \texttt{.deb} et un fichier \texttt{.changes}
    \begin{itemize}
    \item \texttt{.changes} : décrit ce qui a été construit ; utilisé pour envoyer le
paquet
    \end{itemize}
  \end{itemize}
\end{frame}
\subsection{Installation et test des paquets}
\begin{frame}{Installation et test des paquets}
  \begin{itemize}
  \item Installer le paquet : \textttc{debi} (utilise \texttt{.changes} pour savoir
quoi installer) \br
  \item Afficher le contenu du paquet : \texttt{{\color{rouge}debc}
../monpaquet<TAB>.changes} \br
  \item Comparer le paquet avec une version précédente :\\ 
\texttt{{\color{rouge}debdiff} ../monpaquet\_1\_*.changes
../monpaquet\_2\_*.changes}\\ ou pour comparer les sources:\\ 
\texttt{{\color{rouge}debdiff} ../monpaquet\_1\_*.dsc
../monpaquet\_2\_*.dsc}\\
    \br
  \item Vérifier le paquet avec \texttt{lintian} (analyseur statique) :\\ 
\texttt{{\color{rouge}lintian} ../monpaquet<TAB>.changes}\\ \texttt{lintian
-i} : donne plus d'informations sur les erreurs \\ \texttt{lintian -EviIL
+pedantic} : montre encore plus de problèmes\br
  \item Envoyer le paquet dans Debian (\textttc{dput}) (exige un peu de
configuration) \br
  \item Gérer une archive privée avec \textttc{reprepro}  ou \textttc{aptly}\\ 
Documentation: \url{https://wiki.debian.org/HowToSetupADebianRepository}
  \end{itemize}
\end{frame}
\section{Travaux pratiques nº~1 : modifier le paquet grep}
\begin{frame}{Travaux pratiques nº~1 : modifier le paquet grep}
  \begin{enumerate}
  \item Rendez-vous sur \url{http://ftp.debian.org/debian/pool/main/g/grep/} et
téléchargez la version~2.12-2 du paquet
    \begin{itemize}
		   \item Si le paquet source n'est pas décompressé automatiquement, décompressez-le
avec \texttt{dpkg-source~-x~grep\_*.dsc}
    \end{itemize}

  \item Regardez les fichiers contenus dans \texttt{debian/}.
    \begin{itemize}
    \item 		Combien de paquets binaires sont produits par ce paquet source ?
    \item 		Quel assistant d'empaquetage ce paquet utilise-t-il ?
    \end{itemize}
    \hbr
  \item Construisez le paquet
    \hbr
  \item Nous allons maintenant modifier le paquet. Ajoutez une entrée au journal des
modifications et augmentez le numéro de version.
    \hbr
  \item Désactivez maintenant la gestion des expressions rationnelles de Perl (c'est
une option de \texttt{./configure})
    \hbr
  \item Reconstruisez le paquet
    \hbr
  \item Comparez le paquet d'origine et le nouveau avec debdiff
    \hbr
  \item Installez le paquet nouvellement construit
  \end{enumerate}
\end{frame}

\section{Sujets avancés sur la construction de paquets}
\subsection{debian/copyright}
\begin{frame}[fragile=singleslide]{debian/copyright}
  \hbr
  \begin{itemize}
  \item Informations de copyright et de licence pour les sources et l'empaquetage
  \item Écrites traditionnellement dans un fichier texte
  \item Nouveau format en langage machine :
{\small\url{https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/}}
  \end{itemize}
  \seprule
  \begin{lstlisting}[basicstyle=\ttfamily\scriptsize]
Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
Upstream-Name: X Solitaire
Source: ftp://ftp.example.com/pub/games

Files: *
Copyright: Copyright 1998 John Doe <jdoe@example.com>
License: GPL-2+
 This program is free software; you can redistribute it
 [...]
 .
 On Debian systems, the full text of the GNU General Public
 License version 2 can be found in the file
 `/usr/share/common-licenses/GPL-2'.

Files: debian/*
Copyright: Copyright 1998 Jane Smith <jsmith@example.net>
License:
 [TEXTE DE LA LICENCE]
\end{lstlisting}
\end{frame}



\subsection{Modifier les sources amont}
\begin{frame}{Modifier les sources amont}
  Souvent nécessaire :
  \begin{itemize}
  \item Corriger des bogues ou faire des modifications spécifiques à Debian
    \hbr
  \item Rétroporter des corrections depuis une version amont plus récente
  \end{itemize}
  \br
  {P}lusieurs méthodes existent : 
  \begin{itemize}
  \item Modifier directement les fichiers
    \begin{itemize}
    \item Simple
    \item Mais aucun moyen de suivre et de documenter les modifications
    \end{itemize}
    \hbr
  \item Utiliser les systèmes de gestion de correctifs
    \begin{itemize}
    \item Facilite l'intégration de vos modifications en amont
    \item Facilite le partage des corrections avec les dérivées
    \item Donne plus de visibilité à vos modifications\\ 
\url{http://patch-tracker.debian.org/} (actuellement en panne)
    \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}{Systèmes de gestion de correctifs}
  \begin{itemize}
  \item Principe : les modifications sont stockées sous forme de correctifs dans
\texttt{debian/patches/}
    \br
  \item Correctifs appliqués et retirés lors de la construction
    \br
  \item Avant : plusieurs implémentations -- \textsl{simple-patchsys}
(\textsl{cdbs}), \textsl{dpatch}, \textbf{\textsl{quilt}}
    \begin{itemize}
  \item Chacune prend en charge deux cibles \texttt{debian/rules} :
    \begin{itemize}
    \item \texttt{debian/rules patch} : applique tous les correctifs
    \item \texttt{debian/rules unpatch} : retire tous les correctifs
    \end{itemize}
	  \hbr
  \item Plus de documentation : \url{https://wiki.debian.org/debian/patches}
  \end{itemize}
  \br
  \item \textbf{Nouveau format de paquet source avec système de gestion de correctifs
intégré : 3.0~(quilt)}
  \begin{itemize}
  \item Solution recommandée
	  \hbr
  \item Vous devez apprendre \textsl{quilt}\\ 
\url{http://perl-team.pages.debian.net/howto/quilt.html}
    \hbr
  \item Outil indépendant du système de correctifs dans \texttt{devscripts} :
\texttt{edit-patch}
  \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}[fragile=singleslide]{Documentation des correctifs}
  \begin{itemize}
	  \item En-têtes normalisés au début du correctif
    \br
  \item Documentation dans DEP-3 -- Patch Tagging Guidelines \\(lignes directrices
de l'étiquetage d'un correctif)\\ \url{http://dep.debian.net/deps/dep3/} 
  \end{itemize}
  \vfill
\seprule
  \begin{lstlisting}[basicstyle=\ttfamily\footnotesize]
Description: Fix widget frobnication speeds
 Frobnicating widgets too quickly tended to cause explosions.
Forwarded: http://lists.example.com/2010/03/1234.html
Author: John Doe <johndoe-guest@users.alioth.debian.org>
Applied-Upstream: 1.2, http://bzr.foo.com/frobnicator/revision/123
Last-Update: 2010-03-29

--- a/src/widgets.c
+++ b/src/widgets.c
@@ -101,9 +101,6 @@ struct {
\end{lstlisting}
\end{frame}

\subsection{Agir durant l'installation et la suppression}
\begin{frame}{Agir durant l'installation et la suppression}
  \begin{itemize}
  \item Décompresser le paquet ne suffit pas toujours
    \hbr
  \item Créer/supprimer des utilisateurs système, démarrer/arrêter des services,
gérer des \textsl{alternatives}
    \hbr
  \item Cela se fait dans \textsl{les scripts du responsable}\\ \texttt{preinst,
postinst, prerm, postrm}
    \begin{itemize}
	    \item  debhelper peut créer des bribes pour les actions classiques
    \end{itemize}
    \hbr
  \item Documentation :
    \begin{itemize}
    \item La Charte Debian, chapitre 6\\ {\footnotesize
\url{https://www.debian.org/doc/debian-policy/ch-maintainerscripts}}
      
      \hbr
    \item Manuel de référence du développeur, chapitre 6.4\\ {\scriptsize
\url{https://www.debian.org/doc/developers-reference/best-pkging-practices.html}}
      \hbr
    \item {\footnotesize
\url{https://people.debian.org/~srivasta/MaintainerScripts.html}}
    \end{itemize}
    \br
  \item Interagir avec l'utilisateur
    \begin{itemize}
    \item Cela doit se faire avec \textbf{debconf}
      \hbr
    \item Documentation : \texttt{debconf-devel(7)} (paquet \texttt{debconf-doc})
    \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}[fragile=singleslide]{Surveiller les versions amont}
  \begin{itemize}
  \item Préciser dans \texttt{debian/watch} où chercher (voir \texttt{uscan(1)})
    \begin{lstlisting}[basicstyle=\ttfamily\footnotesize]
version=3

http://tmrc.mit.edu/mirror/twisted/Twisted/(\d\.\d)/ \
  Twisted-([\d\.]*)\.tar\.bz2
    \end{lstlisting}
    \br
  \item Il y a des systèmes de suivi automatique des nouvelles versions amonts, qui
notifient le mainteneur sur plusieurs systèmes d'information dont
\url{https://tracker.debian.org/} et \url{https://udd.debian.org/dmd/}
    \br
  \item \texttt{uscan} : lance une vérification à la main
    \br
  \item \texttt{uupdate} : tente de mettre à jour votre paquet vers la version la
plus récente
  \end{itemize}
\end{frame}

\subsection{Avec un gestionnaire de versions (SVN, Git)}
\begin{frame}[fragile=singleslide]{Empaqueter avec un gestionnaire de versions :}
  \begin{itemize}
  \item Plusieurs outils facilitent la gestion des branches et des étiquettes lors
de votre empaquetage : \texttt{svn-buildpackage}, \texttt{git-buildpackage}
    \hbr
  \item Exemple : \texttt{git-buildpackage}
    \begin{itemize}
    \item la branche \texttt{upstream} pour suivre les sources amont avec les
étiquettes \texttt{upstream/\textsl{version}}
    \item la branche \texttt{master} suit le paquet Debian
    \item les étiquettes \texttt{debian/\textsl{version}} pour chaque envoi
    \item la branche \texttt{pristine-tar} pour pouvoir reconstruire l'archive tar
amont
    \end{itemize}
    Doc:
\url{http://honk.sigxcpu.org/projects/git-buildpackage/manual-html/gbp.html}
    \hbr
  \item Les champs \texttt{Vcs-*} de \texttt{debian/control} pour localiser le dépôt
	  \begin{itemize}
		\item \url{https://wiki.debian.org/Salsa}
	\end{itemize}
\end{itemize}
  \begin{lstlisting}[basicstyle=\ttfamily\scriptsize]
Vcs-Browser: https://salsa.debian.org/debian/devscripts
Vcs-Git: https://salsa.debian.org/debian/devscripts.git
  \end{lstlisting}
  \begin{lstlisting}[basicstyle=\ttfamily\scriptsize]
Vcs-Browser: https://salsa.debian.org/perl-team/modules/packages/libwww-perl
Vcs-Git: https://salsa.debian.org/perl-team/modules/packages/libwww-perl.git
  \end{lstlisting}
  \begin{itemize}
  \item Interface indépendante du VCS : \texttt{debcheckout}, \texttt{debcommit},
\texttt{debrelease}\\
    \begin{itemize}
	    \item     \texttt{debcheckout grep} : rapatrie le paquet source du dépôt Git
    \end{itemize}
\end{itemize}
\end{frame}

\subsection{Rétroportage de paquets}
\begin{frame}{Rétroportage de paquets}
  \begin{itemize}
  \item But : utiliser une version plus récente du paquet sur un système plus
ancien\\ p.ex. utiliser \textsl{mutt} de Debian \textsl{unstable} sur Debian
\textsl{stable}
	\br
  \item Idée générale :
	  \begin{itemize}
		\item Prendre le paquet source de Debian unstable
		\hbr
		\item Le modifier pour qu'il se construise et fonctionne correctement sur Debian
stable
		\begin{itemize}
			\item Parfois trivial (aucun changement nécessaire)
			\item Parfois difficile
			\item Parfois impossible (nombreuses dépendances indisponibles)
		\end{itemize}
	\end{itemize}
	\br
   \item Certains rétroportages sont fournis et maintenus par le projet Debian\\ 
\url{http://backports.debian.org/}
\end{itemize}
\end{frame}



\section{Maintenir des paquets dans Debian}
\subsection{Archive Debian et suites}
\begin{frame}{Archive Debian et suites}
  \begin{center}
	  \resizebox{\textwidth}{!}{
    \begin{tikzpicture}[
	    people/.style={shape=ellipse,draw,thick},
      suite/.style={shape=rectangle,draw},
	    devel/.style={fill=red!30!white},
	    test/.style={fill=orange!30!white},
	    prod/.style={fill=green!30!white,node distance=2cm},
	    internal/.style={},
	    old/.style={fill=gray!30!white},
	    veryold/.style={fill=gray!70!white},
      arr/.style={very thick},
	    uploads/.style={decorate,decoration={snake,amplitude=.4mm,segment length=2mm,post length=1mm}},
	    migrations/.style={};
	    command/.style={text=rouge,font=\ttfamily},
	    legend/.style={font=\small}
	    ]
      
      \draw node[suite,prod] (sec) {security}; \draw node[suite,prod,right=of sec]
(su) {stable-updates}; \draw node[suite,prod,right=of su] (st) {stable};
\draw node[suite,old,node distance=0.3cm,below=of st] (os) {oldstable};
\draw node[suite,veryold,node distance=0.3cm,below=of os] (ar)
{archive.d.o}; \draw node[suite,prod,right=of st] (bp) {backports}; \draw
node[suite,test] (spu) at ($(su) + (-0.6,2.5)$) {stable-proposed-updates};
\draw node[suite,internal] (sn) at ($(st) + (-1.8,1.4)$) {stable-new}; \draw
node[suite,test,node distance=1.5cm,above=of st] (te) {testing}; \draw
node[suite,devel,above=of te] (sid) {unstable}; \draw node[suite,devel]
(exp) at ($(sid) + (2.5,0.5)$) {experimental}; \draw node[suite,devel] (tpu)
at ($(te)!0.5!(sid) + (2.5,0)$) {testing-proposed-updates}; \draw
node[people,above=of sid] (dd) {développeur}; \draw node[people,node
distance=3cm,left=of dd] (secteam) {équipe sécurité}; \draw[arr,uploads,->]
(dd) -- (sid); \draw[arr,uploads,->] (dd) -- (exp);
\draw[arr,uploads,->,bend right=8] (dd) to (tpu); \draw[arr,uploads,->]
(secteam) -- (sid); \draw[arr,uploads,->] (secteam) -- (sec);
\draw[arr,uploads,->] (dd) to (spu); \draw[arr,uploads,->] plot [smooth,
tension=0.75] coordinates { (dd.east) ($(exp.north east)+(0.1,0.1)$)
($(tpu.east)+(0.2,0)$)  ($(bp.north east) + (-0.4,0)$) };
\draw[arr,migrations,->] (tpu) -- (te); \draw[arr,migrations,->] (sid) --
(te); \draw[arr,migrations,->] (te) -- (st) node
[midway,align=left,midway,right,font=\footnotesize] {stable\\ release};
\draw[arr,migrations,->] (sec) -- (sn); \draw[arr,migrations,->] (sn) to
node [pos=0.2] (spulabel) {} (st); \draw
node[font=\footnotesize,align=right] at ($(spulabel) + (-0.4,-0.45)$)
{stable \\ point \\ release}; \draw[arr,migrations,->] (spu) to (sn);
\draw[arr,migrations,->] (spu) -- (su); \draw[arr,migrations,->] (st) --
(os); \draw[arr,migrations,->] (os) -- (ar); \coordinate (legend) at
(-2,-1); \draw[arr,uploads,->] (legend) -- ($(legend) + (0.7,0)$) node
[right,legend] {envoi de paquets}; \coordinate[node distance=1.1em,below=of
legend] (legend2); \draw[arr,migrations,->] (legend2) -- ($(legend2) +
(0.7,0)$) node [right,legend] {migrations de paquets entre les suites};
\coordinate[node distance=1.5em,below=of legend2] (legend3); \draw
node[right,suite,devel,legend] (ldev) at (legend3) {développement}; \draw
node[node distance=0.1cm,right=of ldev,suite,test,legend] (ltest) {test};
\draw node[node distance=0.1cm,right=of ltest,suite,internal,legend] (lint)
{interne}; \draw node[node distance=0.1cm,right=of lint,suite,prod,legend]
(lprod) {production}; \draw ($(legend.north west) + (-0.1,0.25)$) rectangle
($(lprod.south east) + (0.1,-0.1)$); \draw
node[font=\bf,red!70!white,align=center] (tnext) at ($(te.east) + (2,-0.1)$)
{préparation de la \\ prochaine release}; \draw
node[font=\bf,green!70!black,align=center] (tsrm) at ($(sec.north east) +
(1,1)$) {gestion des\\ releases stables}; \pgfdeclarelayer{background}
\pgfdeclarelayer{foreground} \pgfsetlayers{background,main,foreground}
\begin{pgfonlayer}{background}
	    \fill[red!10!white] plot [smooth cycle,tension=0.55] coordinates {
($(sid.north west) + (-0.1,0.1)$) ($(exp.north east)+(0.1,0.1)$)
($(tpu.south east)+(0.1,-0.1)$) ($(tnext.south) + (0.6,0)$) ($(te.south
west) + (0.1,-0.1)$)  }; \fill[green!10!white] plot [smooth
cycle,tension=0.55] coordinates { ($(spu.north west) + (-0.1,0.1)$)
($(spu.north east)+(0.1,0.1)$) ($(sn.north east)+(0.1,0.1)$) ($(st.north
east) + (0.1,0.5)$) ($(bp.north east) + (0.1,0.1)$)  ($(bp.south east) +
(0.1,-0.1)$) ($(sec.south west) + (-0.1,-0.1)$)  };
\end{pgfonlayer}

    \end{tikzpicture}
	  }
  \end{center}
	\begin{flushright}
		\tiny Basé sur un schéma par Antoine
Beaupr\'e. \url{https://salsa.debian.org/debian/package-cycle}~~~~~~~~~~~~
	\end{flushright}
\end{frame}

\begin{frame}{Suites pour le développement}
		\begin{itemize}
			\item Les nouvelles versions de paquets sont envoyées dans \textbf{unstable}
(\textbf{sid})
				\hbr
			\item Les paquets migrent de \textbf{unstable} vers \textbf{testing} sur la base
de plusieurs critères (par exemple, a été dans unstable depuis 10 jours,
sans régression)
				\hbr
			\item Les nouveaux paquets peuvent aussi être envoyés vers:
				\begin{itemize}
					\item \textbf{experimental} (pour des paquets plus \textsl{expérimentaux}, comme
quand la nouvelle version n'est pas prête pour remplacer la version dans
unstable)
						\hhbr
					\item \textbf{testing-proposed-updates}, pour mettre à jour la version dans
\textbf{testing} sans passer par \textbf{unstable} (c'est rarement utilisé)
				\end{itemize}
		\end{itemize}
\end{frame}

\begin{frame}{Freezer et releaser}
	\begin{itemize}
					\item À un instant donné pendant le cycle d'une nouvelle version, l'équipe
\textsl{release} décide de geler (\textsl{freezer}) testing: les migrations
automatiques de \textbf{unstable} vers \textbf{testing} sont arrêtées, et
remplacées par une relecture manuelle
						\br
		\item Quand l'équipe \textsl{release} considère \textbf{testing} comme prêt pour
la sortie d'une nouvelle version :
			\begin{itemize}
				\item La suite \textbf{testing} devient la nouvelle suite \textbf{stable}
					\hhbr
				\item De manière similaire, l'ancienne \textbf{stable} devient \textbf{oldstable}
					\hhbr
				\item Les versions plus supportées sont déplacées vers \texttt{archive.debian.org}
			\end{itemize}
			\br
		\item Voir \url{https://release.debian.org/}
	\end{itemize}
\end{frame}

\begin{frame}{Suites des versions stables et leur gestion}
	\begin{itemize}
		\item Plusieurs suites sont utilisées pour fournir les paquets des versions
stables:
			\hhbr
			\begin{itemize}
				\item \textbf{stable}: la suite principale
					\hbr
				\item \textbf{security} fournit les mises à jour de sécurité sur
\texttt{security.debian.org} (utilisé par l'équipe sécurité). Les
mises-à-jour sont annoncées sur la liste \texttt{debian-security-announce}
					\hbr
				\item \textbf{stable-updates}: mises-à-jour non liées à la sécurité, mais qui
doivent être installées de manière urgente (sans attendre la prochaine
\textsl{point release}): base de données d'antivirus, fuseaux horaires,
etc. Annoncées sur la liste \texttt{debian-stable-announce}
					\hbr
				\item \textbf{backports}: nouvelles versions majeures, basées sur la version dans
\textbf{testing}
			\end{itemize}
			\hbr
		\item La suite \textbf{stable} est mise à jour tous les quelques mois par des
\textsl{stable point releases} (qui n'incluent que des corrections de bugs)
			\hhbr
			\begin{itemize}
				\item Les paquets visant la prochaine \textsl{stable point release} sont envoyés
vers \textbf{stable-proposed-updates} et relus par l'équipe \textsl{release}
			\end{itemize}
			\hbr
		\item La version \textbf{oldstable} a le même ensemble de suites
	\end{itemize}
\end{frame}

\subsection{Plusieurs manières de contribuer à Debian}
\begin{frame}{Plusieurs manières de contribuer à Debian}
  \begin{itemize}
  \item \textbf{La pire} :
    \begin{enumerate}
    \item Empaqueter votre propre application
    \item L'intégrer à Debian
    \item Disparaître
    \end{enumerate}
    \br
  \item \textbf{Les meilleures} :
	  \begin{itemize}
		  \item S'impliquer dans des équipes d'empaquetage Debian
    \begin{itemize}
    \item Beaucoup d'équipes se concentrent sur un ensemble de paquets et ont besoin
d'aide
    \item Liste disponible sur \url{https://wiki.debian.org/Teams}
    \item Excellente façon d'apprendre de contributeurs plus expérimentés
    \end{itemize}
    \br
\item Adopter des paquets existants non maintenus (\textsl{paquets orphelins})
    \br
  \item Apporter un nouveau logiciel à Debian
    \begin{itemize}
    \item Seulement s'il est intéressant ou utile, s'il vous plaît
    \item Y a-t-il une alternative déjà empaquetée pour Debian ?
    \end{itemize}
  \end{itemize}

  \end{itemize}
\end{frame}

\subsection{Adopter des paquets orphelins}
\begin{frame}{Adopter des paquets orphelins}
      \hbr
  \begin{itemize}
    \item Beaucoup de paquets non maintenus dans Debian
    \hbr
  \item Liste complète et marche à suivre : \url{https://www.debian.org/devel/wnpp/}
    \hbr
  \item Ceux installés sur votre machine : \texttt{wnpp-alert}Ceux installés sur
votre machine : \texttt{wnpp-alert}\\ Ou mieux: \texttt{how-can-i-help}
    \hbr
  \item Différents états :
    \begin{itemize}
		    \small
    \item \textbf{O}rphelin : le paquet n'est pas maintenu\\ Adoptez-le s'il vous sied
      \hbr
    \item \textbf{RFA} : \textbf{R}equest \textbf{F}or \textbf{A}dopter (cherche un
adoptant)\\ Le responsable cherche un adoptant, mais il continue son travail
en attendant\\ Adoptez-le s'il vous sied. L'envoi d'un courriel au
responsable actuel est poli
      \hbr
    \item \textbf{ITA} : \textbf{I}ntent \textbf{T}o \textbf{A}dopt (en cours
d'adoption) \\Quelqu'un prévoit d'adopter le paquet. Vous pourriez proposer
votre aide !
      \hbr
    \item \textbf{RFH} : \textbf{R}equest \textbf{F}or \textbf{H}elp (recherche
d'aide) \\ Le responsable cherche de l'aide
    \end{itemize}
    \hbr
  \item Certains paquets non maintenus ne sont pas identifiés comme tels \arr pas
encore officiellement orphelins
    \hbr
  \item En cas de doute, demandez sur \texttt{debian-qa@lists.debian.org} \\ ou
\texttt{\#debian-qa} sur \texttt{irc.debian.org}
  \end{itemize}
\end{frame}

\begin{frame}[fragile=singleslide]{Adopter un paquet : un exemple}
\begin{lstlisting}[basicstyle=\ttfamily\footnotesize,escapeinside=\{\}]
From: Vous <vous@votredomaine>
To: 640454@bugs.debian.org, control@bugs.debian.org
Cc: Francois Marier <francois@debian.org>
Subject: ITA: verbiste -- French conjugator

retitle 640454 ITA: verbiste -- French conjugator
owner 640454 !
thanks

Hi,

I am using verbiste and I am willing to take care of the package.

Cheers,

Vous
\end{lstlisting}

\begin{itemize}
\item Il est poli de contacter le responsable précédent (surtout si le paquet
était signalé comme cherchant un adoptant et non comme orphelin)
\item Très bonne idée aussi de contacter le projet amont
\end{itemize}
\end{frame}

\subsection{Intégrer votre paquet dans Debian}
\begin{frame}{Intégrer votre paquet dans Debian}
\begin{itemize}
\item Aucun besoin d'un statut officiel pour intégrer son paquet dans Debian
	\begin{enumerate}
		\item Soumettez un bogue \textbf{ITP} (\textbf{I}ntent \textbf{T}o
\textbf{P}ackage) avec \texttt{reportbug wnpp}
			\hbr
		\item Préparez un paquet source
			\hbr
		\item Trouvez un développeur Debian qui va parrainer votre paquet
	\end{enumerate}
\br
\item Statuts officiels (quand vous serez un responsable de paquets expérimenté) :
	\begin{itemize}
		\item \textbf{Debian Maintainer (DM) :}\\ Droit d'envoyer vos propres paquets\\ 
Voir \url{https://wiki.debian.org/DebianMaintainer}
			\hbr
		\item \textbf{Debian Developer (DD) :}\\ Membre du projet Debian \\ Peut voter et
envoyer n'importe quel paquet
	\end{itemize}
\end{itemize}
\end{frame}

\begin{frame}{Points à vérifier avant de demander un parrainage}
\begin{itemize}
	\item Debian met \textbf{fortement l'accent sur la qualité}
\hbr
\item En général, \textbf{les parrains et marraines sont difficiles à trouver et
très occupés}
\begin{itemize}
\item Assurez-vous que votre paquet est prêt avant de demander un parrainage
\end{itemize}
\hbr
\item Points à vérifier :
\begin{itemize}
\item Évitez les oublis de dépendances de construction : assurez-vous que la
construction de votre paquet fonctionne dans un environnement
\textsl{chroot} \textsl{sid} propre
\begin{itemize}
\item L'utilisation de \texttt{pbuilder} est recommandée
\end{itemize}
\hbr
\item Lancez \texttt{lintian -EviIL +pedantic} sur votre paquet
\begin{itemize}
\item Vous devez corriger les erreurs et faire de votre mieux pour corriger les
autres problèmes
\end{itemize}
\hbr
\item Testez largement votre paquet, bien sûr
\end{itemize}
\hbr
\item En cas de doute, demandez de l'aide
\end{itemize}
\end{frame}

\subsection{Où trouver de l'aide ?}
\begin{frame}{Où trouver de l'aide ?}
	\hbr
  L'aide dont vous avez besoin :
  \begin{itemize}
  \item conseils et réponses à vos questions, relecture de code
  \item parrainage pour les envois, une fois votre paquet prêt
  \end{itemize}
  \hbr
  Vous pouvez obtenir de l'aide :
  \begin{itemize}
	  \item \textbf{autres membres d'une équipe d'empaquetage : la meilleure solution}
    \begin{itemize}
    \item liste des équipes : \url{https://wiki.debian.org/Teams}
    \end{itemize}
    \hbr
  \item le groupe \textbf{Debian Mentors} (si le paquet ne correspond à aucune
équipe)
    \begin{itemize}
    \item \url{https://wiki.debian.org/DebianMentorsFaq}
    \item liste de diffusion : \url{debian-mentors@lists.debian.org}\\ {\small (une
autre manière d'apprendre par hasard)}
    \item IRC : \texttt{\#debian-mentors} sur \texttt{irc.debian.org}
    \item \url{http://mentors.debian.net/}
    \item documentation : \url{http://mentors.debian.net/intro-maintainers}
    \end{itemize}
    \hbr
  \item \textbf{listes de diffusion localisées} (pour obtenir de l'aide dans votre
langue)
    \begin{itemize}
  \item \texttt{debian-devel-\{french,italian,portuguese,spanish\}@lists.d.o}
  \item liste complète : \url{https://lists.debian.org/devel.html}
  \item ou les listes d'utilisateurs : \url{https://lists.debian.org/users.html}
  \end{itemize}
  \end{itemize}
\end{frame}

\subsection{Plus de documentation :}
\begin{frame}{Plus de documentation :}
  \begin{itemize}
  \item Le coin des développeurs Debian\\ \url{https://www.debian.org/devel/}\\ 
{\small Liens vers de nombreuses ressources sur le développement Debian}
    \hbr
  \item Guide pour les nouveaux mainteneurs\\ 
\url{https://www.debian.org/doc/manuals/debmake-doc/}
    \hbr
  \item Manuel de référence du développeur Debian\\ 
\url{https://www.debian.org/doc/developers-reference/}\\ {\small
Essentiellement sur les procédures Debian mais contient aussi quelques
bonnes pratiques d'empaquetage (chapitre 6)}
    \hbr
  \item La Charte Debian\\ \url{https://www.debian.org/doc/debian-policy/}\\
    
    {\small \begin{itemize} \item \small Toutes les exigences que doit
satisfaire chaque paquet \item \small Règles spécifiques pour Perl, Java,
Python\ldots \end{itemize}}
    \hbr
    
  \item Guide d'empaquetage d'Ubuntu\\ 
\url{https://packaging.ubuntu.com/html/}
  \end{itemize}
\end{frame}

\subsection{Tableau de bord Debian pour les responsables}
\begin{frame}{Tableau de bord Debian pour les responsables}
  \begin{itemize}
	  \item \textbf{Pour une vision par paquet source} :\\ 
\url{https://tracker.debian.org/dpkg}
    \br
  \item \textbf{Pour une vision par responsable/équipe} : aperçu des paquets d'un
développeur (DDPO : Developer's Packages Overview) \\ 
\url{https://qa.debian.org/developer.php?login=pkg-ruby-extras-maintainers@lists.alioth.debian.org}
    \br
  \item \textbf{Pour une vision en liste de tâches} : tableau de bord du responsable
Debian (DMD : Debian Maintainer Dashboard)\\ 
\url{https://udd.debian.org/dmd/}
  \end{itemize}
\end{frame}

\begin{frame}{Utilisation du système de suivi des bogues (BTS)}
\begin{itemize}
\item Une façon unique de gérer les bogues
\begin{itemize}
\item interface web pour visualiser les bogues
\item interface par courrier électronique pour modifier les bogues
\end{itemize}
\hbr
\item Ajouter des informations complémentaires aux bogues :
	\begin{itemize}
		\item écrivez un message à  \texttt{123456@bugs.debian.org} (pour mettre en copie
la personne ayant soumis le bogue, ajoutez
\texttt{123456-submitter@bugs.debian.org})
	\end{itemize}
\hbr
\item Changer le statut d'un bogue :
\begin{itemize}
\item envoyez des commandes à \texttt{control@bugs.debian.org}
\item interface en ligne de commande : commande \texttt{bts} dans le paquet
\texttt{devscripts}
\item documentation : \url{https://www.debian.org/Bugs/server-control}
\end{itemize}
\hbr
\item Soumettre un rapport de bogue : utilisez \texttt{reportbug}
\begin{itemize}
\item normalement utilisé avec un serveur de courrier local : installez
\texttt{ssmtp} ou \texttt{nullmailer}
\item ou utilisez \texttt{reportbug -\@-template}, puis envoyez « à la main » le
message à l'adresse \texttt{submit@bugs.debian.org}
\end{itemize}
\end{itemize}
\end{frame}

\begin{frame}{Utilisation du BTS : exemples}
\begin{itemize}
\item Envoyer un message au bogue et à la personne qui l'a soumis :\\ 
\url{https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=680822\#10}
\hbr
\item Étiqueter et changer la sévérité :\\ 
\url{https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=680227\#10}
\hbr
\item Réattribuer, changer la sévérité, changer le titre\ldots : \\ 
\url{https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=680822\#93}
\begin{itemize}
	\item \texttt{notfound}, \texttt{found}, \texttt{notfixed}, \texttt{fixed} utilisé
pour le \textbf{suivi de version} \\ Lisez
\url{https://wiki.debian.org/HowtoUseBTS\#Version\_tracking}
\end{itemize}
\hbr
\item Utiliser des étiquettes utilisateur :
\url{https://bugs.debian.org/cgi-bin/bugreport.cgi?msg=42;bug=642267}\\ 
Consultez \url{https://wiki.debian.org/bugs.debian.org/usertags}
\hbr
\item Documentation du BTS :
\begin{itemize}
\item \url{https://www.debian.org/Bugs/}
\item \url{https://wiki.debian.org/HowtoUseBTS}
\end{itemize}
\end{itemize}
\end{frame}

\subsection{Plus intéressé par Ubuntu ?}
\begin{frame}{Plus intéressé par Ubuntu ?}
  \begin{itemize}
  \item Ubuntu gère essentiellement les différences avec Debian
    \br
  \item Pas de concentration sur des paquets spécifiques\\ Mais une collaboration
avec les équipes Debian
    \br
  \item Il est recommandé en général d'envoyer les nouveaux paquets d'abord dans
Debian\\ \url{https://wiki.ubuntu.com/UbuntuDevelopment/NewPackages}
    \br
  \item Peut-être une meilleure idée :
    \begin{itemize}
    \item S'impliquer dans une équipe Debian et faire le lien avec Ubuntu
      \hbr
    \item Faciliter la réduction les divergences, trier les bogues sur Launchpad
      \hbr
    \item Beaucoup d'outils Debian peuvent aider :
      \begin{itemize}
      \item Colonne Ubuntu sur l'aperçu des paquets du développeur
      \item Encart Ubuntu sur le système de suivi des paquets
      \item Réception des courriels de bogues Launchpad au moyen du PTS
      \end{itemize}
    \end{itemize}
  \end{itemize}
\end{frame}

\section{Conclusions}
\subsection{Conclusions}
\begin{frame}{Conclusions}
  \begin{itemize}
  \item Vous avez un aperçu complet de la construction de paquets Debian
    \br
  \item Mais vous devrez lire plus de documentation
    \br
  \item Les bonnes pratiques ont évolué avec le temps
    \begin{itemize}
    \item Si vous n'êtes pas sûr, utilisez l'assistant d'empaquetage de paquets
\textbf{dh}, et le format \textbf{3.0 (quilt)} 
    \end{itemize}
  \end{itemize}
  \vfill
  \centerline{\large Vos retours à : \textbf{packaging-tutorial@packages.debian.org}}
\end{frame}

\subsection{Mentions légales}
\begin{frame}{Mentions légales}

  Copyright \copyright{} 2011--2019 Lucas Nussbaum -- lucas@debian.org
  \br

  {\small \textbf{Ce document est un logiciel libre}: vous pouvez le
redistribuer et le modifier, selon votre choix, sous : \hbr \begin{itemize}
\item les termes de la General Public License GNU publiée par la Fondation
du logiciel libre, version 3 de la License, ou (si vous préférez) toute
version supérieure.\\ \url{http://www.gnu.org/licenses/gpl.html} \br \item
les termes de la licence Creative Commons Attribution-ShareAlike 3.0
Unported.\\ \url{http://creativecommons.org/licenses/by-sa/3.0/}
\end{itemize} }
\end{frame}

\subsection{Contribuer à ce tutoriel}
\begin{frame}{Contribuer à ce tutoriel}
	\begin{itemize}
		\item Contribuer :
			\begin{itemize}
				\item{\small \texttt{apt-get source packaging-tutorial}}
					\hbr
				\item  {\small \texttt{debcheckout packaging-tutorial}}
					\hbr
				\item  {\small \texttt{git clone\\ 
https://salsa.debian.org/debian/packaging-tutorial.git}}
					\hbr
				\item {\small \url{https://salsa.debian.org/debian/packaging-tutorial}}
					\hbr
				\item {\small Soumettez des rapports de bogues :
\url{bugs.debian.org/src:packaging-tutorial}}
			\end{itemize}
			\br
		\item Envoyez vos retours :
			\begin{itemize}
				\item \href{mailto:packaging-tutorial@packages.debian.org}{\textbf{\texttt{mailto:packaging-tutorial@packages.debian.org}}}
				\begin{itemize}
					\item{\small Qu'est-ce qui doit être ajouté à ce tutoriel ?}
				\item {\small Qu'est-ce qui doit être amélioré ?}
				\end{itemize}
					\hbr
				\item{\small \texttt{reportbug packaging-tutorial}}
			\end{itemize}
	\end{itemize}
\end{frame}

\section{Travaux pratiques supplémentaires}

\subsection{Travaux pratiques nº~2 : empaqueter GNUjump}
\begin{frame}{Travaux pratiques nº~2 : empaqueter GNUjump}
	\begin{enumerate}
		\item Téléchargez GNUjump~1.0.8 depuis
\url{http://ftp.gnu.org/gnu/gnujump/gnujump-1.0.8.tar.gz}
			\br
		\item Créez un paquet Debian
			\begin{itemize}
				\item Installez les dépendances de construction du paquet
				\item Corrigez des bugs
				\item Vous obtenez un paquet de base fonctionnel
				\item Terminez en complétant \texttt{debian/control} et d'autres fichiers
			\end{itemize}
			\br
		\item Profitez
	\end{enumerate}
\centerline{\includegraphics[width=5cm]{figs/gnujump.png}}
\end{frame}

\begin{frame}[fragile=singleslide]{Travaux pratiques nº~2 : GNUjump (astuces)}
	\begin{itemize}
		\item Créez un paquet source basique : \texttt{dh\_make}
		\item Pour commencer, créer un fichier source \textsl{1.0} est plus facile que
\textsl{3.0 (quilt)} (à changer dans \texttt{debian/source/format})
		\item Pour chercher des dépendances de construction manquantes, trouvez un fichier
manquant, et utilisez\texttt{apt-file} pour trouver le paquet manquant
correspondant
		\item Si vous rencontrez cette erreur:
\begin{lstlisting}[basicstyle=\ttfamily\tiny]
/usr/bin/ld: SDL_rotozoom.o: undefined reference to symbol 'ceil@@GLIBC_2.2.5'
//lib/x86_64-linux-gnu/libm.so.6: error adding symbols: DSO missing from command line
collect2: error: ld returned 1 exit status
Makefile:376: recipe for target 'gnujump' failed
\end{lstlisting}
			Vous devez ajouter \texttt{-lm} sur la ligne de commande du lieur:\\ Editez
\texttt{src/Makefile.am} et remplacez
\begin{lstlisting}[basicstyle=\ttfamily\footnotesize]
gnujump_LDFLAGS = $(all_libraries)
\end{lstlisting}
					par
\begin{lstlisting}[basicstyle=\ttfamily\footnotesize]
gnujump_LDFLAGS = -Wl,--as-needed
gnujump_LDADD = $(all_libraries) -lm
\end{lstlisting}
				Puis exécutez \texttt{autoreconf -i}
	\end{itemize}
\end{frame}

\subsection{Travaux pratiques nº~3 : une bibliothèque Java}
\begin{frame}{Travaux pratiques nº~3 : une bibliothèque Java}
\begin{enumerate}
	\item Jetez un coup d'œil sur la documentation pour la construction de paquets
Java :\\
		\begin{itemize}
		\item \url{https://wiki.debian.org/Java}
      \hbr
		\item \url{https://wiki.debian.org/Java/Packaging}
      \hbr
		\item \url{https://www.debian.org/doc/packaging-manuals/java-policy/}
      \hbr
		\item \texttt{/usr/share/doc/javahelper/tutorial.txt.gz}
		\end{itemize}
		\br
	\item Téléchargez IRClib sur \url{http://moepii.sourceforge.net/}
		\br
	\item Empaquetez-la
\end{enumerate}
\end{frame}

\subsection{Travaux pratiques nº~4 : empaqueter un gem Ruby}
\begin{frame}{Travaux pratiques nº~4 : empaqueter un gem Ruby}
\begin{enumerate}
	\item Jetez un coup d'œil sur la documentation pour la construction de paquets
Ruby :\\
		\begin{itemize}
		\item \url{https://wiki.debian.org/Ruby}
      \hbr
		\item \url{https://wiki.debian.org/Teams/Ruby}
      \hbr
		\item \url{https://wiki.debian.org/Teams/Ruby/Packaging}
      \hbr
		\item \texttt{gem2deb(1)}, \texttt{dh\_ruby(1)} (dans le paquet \texttt{gem2deb})
		\end{itemize}
		\hbr
	\item Créez un paquet source Debian élémentaire à partir du gem \texttt{peach} :\\ 
\texttt{gem2deb peach}
	\hbr
	\item Améliorez-le pour qu'il devienne un paquet Debian à part entière
\end{enumerate}
\end{frame}

\subsection{Travaux pratiques nº~5 : module Perl}
\begin{frame}[fragile=singleslide]{Travaux pratiques nº~5 : module Perl}
\begin{enumerate}
	\item Jetez un coup d'œil sur la documentation pour la construction de paquets
Perl :\\
		\begin{itemize}
		\item \url{https://perl-team.pages.debian.net}
      \hbr
		\item \url{https://wiki.debian.org/Teams/DebianPerlGroup}
      \hbr
		\item \texttt{dh-make-perl(1)}, \texttt{dpt(1)} (in the \texttt{pkg-perl-tools}
package)
		\end{itemize}
		\hbr
	\item Créez un paquet source Debian élémentaire à partir du module \texttt{Acme}
de CPAN :\verb|dh-make-perl --cpan Acme|
	\hbr
	\item Améliorez-le pour qu'il devienne un paquet Debian à part entière
\end{enumerate}
\end{frame}

\section{Solutions aux travaux pratiques}

\begin{frame}
	\begin{center}
		\LARGE Solutions aux\\[0.5em] travaux pratiques
	\end{center}
\end{frame}


\subsection{Travaux pratiques nº~1 : modifier le paquet grep}

\begin{frame}{Travaux pratiques nº~1 : modifier le paquet grep}
\begin{enumerate}
  \item Rendez-vous sur \url{http://ftp.debian.org/debian/pool/main/g/grep/} et
téléchargez la version~2.12-2 du paquet

	\item Regardez les fichiers contenus dans \texttt{debian/}.
		\begin{itemize}
			\item 		Combien de paquets binaires sont produits par ce paquet source ?
			\item 		Quel assistant d'empaquetage ce paquet utilise-t-il ?
		\end{itemize}
    \hbr
	\item Construisez le paquet
    \hbr
	\item Nous allons maintenant modifier le paquet. Ajoutez une entrée au journal des
modifications et augmentez le numéro de version.
    \hbr
	\item Désactivez maintenant la gestion des expressions rationnelles de Perl (c'est
une option de \texttt{./configure})
    \hbr
	\item Reconstruisez le paquet
    \hbr
	\item Comparez le paquet d'origine et le nouveau avec debdiff
    \hbr
	\item Installez le paquet nouvellement construit
\end{enumerate}
\end{frame}

\begin{frame}{Récupérer les sources}
\begin{enumerate}
  \item Rendez-vous sur \url{http://ftp.debian.org/debian/pool/main/g/grep/} et
téléchargez la version~2.12-2 du paquet
\end{enumerate}
\begin{itemize}
	\item Utilisez dget pour télécharger le fichier \texttt{.dsc} :\\ {\small
\texttt{dget
http://cdn.debian.net/debian/pool/main/g/grep/grep\_2.12-2.dsc}}
		\hbr
	\item Si vous avez des lignes \texttt{deb-src} pour une version de Debian qui
contient \texttt{grep} version 2.12-2 (à vérifier sur
\url{https://tracker.debian.org/grep}), vous pouvez utiliser:
\texttt{apt-get source grep=2.12-2}\\ ou \texttt{apt-get source
grep/release} (par exemple \texttt{grep/stable})\\ ou, si vous avez de la
chance: \texttt{apt-get source grep}
	\hbr
	\item Le paquet source de \texttt{grep} se compose de trois fichiers :
		\begin{itemize}
			\item \texttt{grep\_2.12-2.dsc}
			\item \texttt{grep\_2.12-2.debian.tar.bz2}
			\item \texttt{grep\_2.12.orig.tar.bz2}
		\end{itemize}
		C'est le cas typique du format « 3.0~(quilt) »
	\hbr
\item Si nécessaire, décompressez le paquet source avec\\ \texttt{dpkg-source -x
grep\_2.12-2.dsc}
\end{itemize}
\end{frame}

\begin{frame}{Faites le tour et construisez le paquet}
	\begin{enumerate}
			\setcounter{enumi}{1}
	\item Regardez les fichiers contenus dans \texttt{debian/}
		\begin{itemize}
			\item 		Combien de paquets binaires sont produits par ce paquet source ?
			\item 		Quel assistant d'empaquetage ce paquet utilise-t-il ?
		\end{itemize}
	\end{enumerate}
	\hbr
	\begin{itemize}
		\item D'après \texttt{debian/control}, ce paquet ne génère qu'un seul paquet
binaire, nommé \texttt{grep}.
			\hbr
		\item D'après \texttt{debian/rules}, ce paquet est un exemple typique de
construction avec l'assistant \textsl{classique} debhelper, n'utilisant ni
\textsl{CDBS} ni \textsl{dh}. On peut voir les différents appels aux
commandes \texttt{dh\_*} dans \texttt{debian/rules}.
	\end{itemize}
	\hbr
	\begin{enumerate}
			\setcounter{enumi}{2}

		\item Construisez le paquet
	\end{enumerate}
	\hbr
	\begin{itemize}
		\item Utilisez la commande \texttt{apt-get build-dep grep} pour installer les
dépendances de construction
		\item Puis \texttt{debuild} ou \texttt{dpkg-buildpackage -us -uc} (prend environ 1
min)
	\end{itemize}
\end{frame}

\begin{frame}{Éditer le journal des modifications}
	\begin{enumerate}
			\setcounter{enumi}{3}

	\item Nous allons maintenant modifier le paquet. Ajoutez une entrée au journal des
modifications et augmentez le numéro de version.
	\end{enumerate}
	\hbr
	\begin{itemize}
		\item \texttt{debian/changelog} est un fichier texte. Vous pourriez l'éditer et
ajouter une nouvelle entrée à la main.
	\hbr
		\item Vous pouvez aussi utiliser \texttt{dch -i}, qui ajoutera une entrée et
ouvrira un éditeur
	\hbr
		\item On peut définir son nom et son adresse électronique via les variables
d'environnement \texttt{DEBFULLNAME} et \texttt{DEBEMAIL}
	\hbr
		\item Reconstruisez le paquet : une nouvelle version du paquet est construite
	\hbr
		\item Le système des versions est décrit à la section 5.6.12 de la Charte Debian\\ 
\url{https://www.debian.org/doc/debian-policy/ch-controlfields}
	\end{itemize}
\end{frame}

\begin{frame}{Désactiver les expressions rationnelles Perl}
	\begin{enumerate}
			\setcounter{enumi}{4}

	\item Désactivez maintenant la gestion des expressions rationnelles de Perl (c'est
une option de \texttt{./configure})
	\item Reconstruisez le paquet
	\end{enumerate}
	\hbr
	\begin{itemize}
	  \item Vérifiez avec \texttt{./configure -{}-help} : l'option pour désactiver les
expressions rationnelles Perl est \texttt{-{}-disable-perl-regexp}
	\hbr
		\item Éditez \texttt{debian/rules} et cherchez la ligne \texttt{./configure}
	\hbr
		\item Ajoutez \texttt{-{}-disable-perl-regexp}
	\hbr
		\item Reconstruisez avec \texttt{debuild} ou \texttt{dpkg-buildpackage -us -uc}
	\end{itemize}
\end{frame}

\begin{frame}{Comparer et tester les paquets}
	\begin{enumerate}
			\setcounter{enumi}{6}

	\item Comparez le paquet d'origine et le nouveau avec debdiff
	\item Installez le paquet nouvellement construit
	\end{enumerate}
	\hbr
	\begin{itemize}
		\item Comparez les paquets binaires : \texttt{debdiff ../*changes}
	\hbr
		\item Comparez les paquets source : \texttt{debdiff ../*dsc}
	\hbr
		\item Installez le paquet nouvellement construit : \texttt{debi}\\ ou \texttt{dpkg
-i ../grep\_<TAB>}
	\hbr
		\item \texttt{grep -P foo} ne fonctionne plus !
	\end{itemize}
\br
Réinstallez la version précédente du paquet :
\begin{itemize}
	\item \texttt{apt-get install -{}-reinstall grep=2.6.3-3} \textit{(= version
précédente)}
\end{itemize}
\end{frame}

\subsection{Travaux pratiques nº~2 : empaqueter GNUjump}
\begin{frame}{Travaux pratiques nº~2 : empaqueter GNUjump}
\begin{enumerate}
	\item Téléchargez GNUjump~1.0.8 depuis
\url{http://ftp.gnu.org/gnu/gnujump/gnujump-1.0.8.tar.gz}
		\br
	\item Créez un paquet Debian
		\begin{itemize}
			\item Installez les dépendances de construction du paquet
			\item Vous obtenez un paquet de base fonctionnel
			\item Terminez en complétant \texttt{debian/control} et d'autres fichiers
		\end{itemize}
		\br
	\item Profitez
\end{enumerate}
\centerline{\includegraphics[width=5cm]{figs/gnujump.png}}
\end{frame}

\begin{frame}[fragile=singleslide]{Pas à pas\ldots}
\begin{itemize}
	\item \texttt{wget http://ftp.gnu.org/gnu/gnujump/gnujump-1.0.8.tar.gz}
		\hbr
	\item \texttt{mv gnujump-1.0.8.tar.gz gnujump\_1.0.8.orig.tar.gz}
		\hbr
	\item \texttt{tar xf gnujump\_1.0.8.orig.tar.gz}
		\hbr
	\item \texttt{cd gnujump-1.0.8/}
		\hbr
	\item \texttt{dh\_make -f ../gnujump-1.0.8.tar.gz}
	\begin{itemize}
		\item \small Type de paquet : un seul binaire (pour l'instant)
	\end{itemize}
\end{itemize}
\begin{lstlisting}[basicstyle=\ttfamily\small]
gnujump-1.0.8$ ls debian/
changelog           gnujump.default.ex   preinst.ex
compat              gnujump.doc-base.EX  prerm.ex
control             init.d.ex            README.Debian
copyright           manpage.1.ex         README.source
docs                manpage.sgml.ex      rules
emacsen-install.ex  manpage.xml.ex       source
emacsen-remove.ex   menu.ex              watch.ex
emacsen-startup.ex  postinst.ex
gnujump.cron.d.ex   postrm.ex
\end{lstlisting}
\end{frame}

\begin{frame}[fragile=singleslide]{Pas à pas\ldots (2)}
\begin{itemize}
	\item Regardez \texttt{debian/changelog}, \texttt{debian/rules},
\texttt{debian/control}\\ (remplis automatiquement par \textbf{dh\_make})
		\hbr
	\item Dans \texttt{debian/control} :\\ \texttt{Build-Depends: debhelper (>=
7.0.50~), autotools-dev}\\ Liste des \textsl{dépendances de construction} =
paquets nécessaires pour construire le paquet
		\hbr
	\item Essayez de construire le paquet comme ça, avec \texttt{debuild} (grâce à la
magie de \textbf{dh})
		\begin{itemize}
			\item Et ajoutez des dépendances jusqu'à ce que la construction puisse se terminer
			\item Astuce : utilisez \texttt{apt-cache search} et \texttt{apt-file} pour
chercher les paquets manquants
			\item Exemple :
\begin{lstlisting}[basicstyle=\ttfamily\footnotesize]
checking for sdl-config... no
checking for SDL - version >= 1.2.0... no
[...]
configure: error: *** SDL version 1.2.0 not found!
\end{lstlisting}
$\rightarrow$ Ajoutez \textbf{libsdl1.2-dev} à \texttt{Build-Depends} et
installez-le.
		\hbr
	\item Mieux : construction dans un environnement propre avec \textbf{pbuilder}
		\end{itemize}
\end{itemize}
\end{frame}

\begin{frame}[fragile=singleslide]{Pas à pas\ldots (3)}
	\begin{itemize}
		\item Les dépendances de construction nécessaires sont \texttt{libsdl1.2-dev,
libsdl-image1.2-dev, libsdl-mixer1.2-dev}

		\item Ensuite, vous devriez rencontrer une autre erreur:
	\end{itemize}
	\begin{lstlisting}[basicstyle=\ttfamily\tiny]
/usr/bin/ld: SDL_rotozoom.o: undefined reference to symbol 'ceil@@GLIBC_2.2.5'
//lib/x86_64-linux-gnu/libm.so.6: error adding symbols: DSO missing from command line
collect2: error: ld returned 1 exit status
Makefile:376: recipe for target 'gnujump' failed\end{lstlisting}
	\begin{itemize}
		\item Ce problème est causé par la \textsl{pourriture logicielle}: gnujump n'a pas
été adapté suite à des changements du lieur.
		\item Si vous utilisez le format source \textbf{1.0}, vous pouvez directement
changer les sources amont.
			\begin{itemize}
				\item Éditer \textsl{src/Makefile.am} and remplacer
\begin{lstlisting}[basicstyle=\ttfamily\footnotesize]
gnujump_LDFLAGS = $(all_libraries)
\end{lstlisting}
					par
\begin{lstlisting}[basicstyle=\ttfamily\footnotesize]
gnujump_LDFLAGS = -Wl,--as-needed
gnujump_LDADD = $(all_libraries) -lm
\end{lstlisting}
				\item Puis exécutez \texttt{autoreconf -i}
			\end{itemize}
	\end{itemize}
\end{frame}

\begin{frame}[fragile=singleslide]{Pas à pas\ldots (4)}
\begin{itemize}
	\item Si vous utilisez le format source \textbf{3.0 (quilt)}, utilisez
\texttt{quilt} pour préparer un patch. (voir
\url{https://wiki.debian.org/UsingQuilt})
\begin{itemize}
\item \texttt{export QUILT\_PATCHES=debian/patches}
\item \texttt{mkdir debian/patches}\\ \texttt{quilt new linker-fixes.patch}\\ 
\texttt{quilt add src/Makefile.am}\\
\hbr
\item Éditer \textsl{src/Makefile.am} and remplacer
\begin{lstlisting}[basicstyle=\ttfamily\footnotesize]
gnujump_LDFLAGS = $(all_libraries)
\end{lstlisting}
par
\begin{lstlisting}[basicstyle=\ttfamily\footnotesize]
gnujump_LDFLAGS = -Wl,--as-needed
gnujump_LDADD = $(all_libraries) -lm
\end{lstlisting}
\hbr
\item \texttt{quilt refresh}
	\hbr
	\item comme \texttt{src/Makefile.am} a été changé, autoreconf doit être appelé
pendant la compilation. Pour le faire automatiquement avec \texttt{dh},
changer l'appel à \texttt{dh} dans \texttt{debian/rules} de: \texttt{dh \$\@
-{}-with autotools-dev}\\ en: \texttt{dh \$\@ -{}-with autotools-dev
-{}-with autoreconf}
		\hbr
\end{itemize}
\end{itemize}
\end{frame}


\begin{frame}[fragile=singleslide]{Pas à pas\ldots (5)}
\begin{itemize}
	\item Le paquet devrait maintenant se construire correctement.
		\hbr
	\item Utilisez \texttt{debc} pour lister le contenu du paquet créé, et
\texttt{debi} pour l'installer et le tester.
		\hbr
	\item Testez le paquet avec \texttt{lintian}
		\begin{itemize}
			\item Absence de problèmes signalés par \texttt{lintian} recommandée (même si pas
strictement nécessaire) pour les paquets envoyés dans Debian
		\hbr
			\item Détection de plus de problèmes : \texttt{lintian -EviIL +pedantic}
		\hbr
			\item Quelques indices :
				\begin{itemize}
					\item Supprimez les fichiers inutiles dans \texttt{debian/}
		\hbr
					\item Complétez \texttt{debian/control}
						\hbr
					\item Installez l'exécutable dans \texttt{/usr/games} en surchargeant
\texttt{dh\_auto\_configure}
		\hbr
					\item Utilisez les attributs de consolidation du compilateur pour augmenter la
sécurité.\\ Consultez \url{https://wiki.debian.org/Hardening}
				\end{itemize}
		\end{itemize}
\end{itemize}
\end{frame}

\begin{frame}{Pas à pas\ldots (6)}
		\begin{itemize}
	\item Comparez votre paquet avec celui déjà empaqueté dans Debian :
		\begin{itemize}
			\item Il rassemble les fichiers de données dans un deuxième paquet, identique pour
toutes les architectures ($\rightarrow$ gain de place dans l'archive Debian)
				\hbr
			\item Il installe aussi un fichier .desktop (pour les menus GNOME/KDE) et
l'intègre dans le menu Debian
				\hbr
			\item Il corrige de petits problèmes en utilisant des correctifs
		\end{itemize}
\end{itemize}
\end{frame}

\subsection{Travaux pratiques nº~3 : une bibliothèque Java}
\begin{frame}{Travaux pratiques nº~3 : une bibliothèque Java}
\begin{enumerate}
	\item Jetez un coup d'œil sur la documentation pour la construction de paquets
Java :\\
		\begin{itemize}
		\item \url{https://wiki.debian.org/Java}
      \hbr
		\item \url{https://wiki.debian.org/Java/Packaging}
      \hbr
		\item \url{https://www.debian.org/doc/packaging-manuals/java-policy/}
      \hbr
		\item \texttt{/usr/share/doc/javahelper/tutorial.txt.gz}
		\end{itemize}
		\br
	\item Téléchargez IRClib sur \url{http://moepii.sourceforge.net/}
		\br
	\item Empaquetez-la
\end{enumerate}
\end{frame}

\begin{frame}{Pas à pas\ldots}
\begin{itemize}
	\item \texttt{apt-get install javahelper}
		\hbr
	\item Créez un paquet source de base : \texttt{jh\_makepkg}
		\begin{itemize}
			\item Bibliothèque
			\item Aucun
			\item Compilateur et exécution libres fournis par défaut
		\end{itemize}
		\hbr
	\item Regardez et corrigez \texttt{debian/*}
		\hbr
	\item \texttt{dpkg-buildpackage -us -uc} ou \texttt{debuild}
		\hbr
	\item \texttt{lintian}, \texttt{debc}, etc.
		\hbr
	\item Comparez votre résultat avec le paquet source \texttt{libirclib-java}
\end{itemize}
\end{frame}

\subsection{Travaux pratiques nº~4 : empaqueter un gem Ruby}
\begin{frame}{Travaux pratiques nº~4 : empaqueter un gem Ruby}
\begin{enumerate}
	\item Jetez un coup d'œil sur la documentation pour la construction de paquets
Ruby :\\
		\begin{itemize}
		\item \url{https://wiki.debian.org/Ruby}
      \hbr
		\item \url{https://wiki.debian.org/Teams/Ruby}
      \hbr
		\item \url{https://wiki.debian.org/Teams/Ruby/Packaging}
      \hbr
		\item \texttt{gem2deb(1)}, \texttt{dh\_ruby(1)} (dans le paquet \texttt{gem2deb})
		\end{itemize}
		\hbr
	\item Créez un paquet source Debian élémentaire à partir du gem \texttt{peach} :\\ 
\texttt{gem2deb peach}
	\hbr
	\item Améliorez-le pour qu'il devienne un paquet Debian à part entière
\end{enumerate}
\end{frame}

\begin{frame}{Pas à pas\ldots}
\texttt{gem2deb peach} :
\begin{itemize}
\item Télécharge le gem depuis rubygems.org
\item Crée une archive .orig.tar.gz adéquate, et la décompresse
\item Initialise un paquet source Debian basé sur les métadonnées du gem
	\begin{itemize}
		\item Nommé \texttt{ruby-\textsl{gemname}}
	\end{itemize}
\item Tente de construire le paquet binaire Debian (ceci peut échouer)
\end{itemize}
\br
\texttt{dh\_ruby} (inclus dans \textsl{gem2deb}) effectue les tâches
spécifiques à Ruby :
\begin{itemize}
	\item Construction d'extentions C pour chaque version de Ruby
	\item Copie les fichiers dans leur répertoire de destination
	\item Mise à jour des interpréteurs à utiliser (« shebangs ») pour les scripts
exécutables
	\item Exécution des tests définis dans \texttt{debian/ruby-tests.rb},
\texttt{debian/ruby-tests.rake}, ou \texttt{debian/ruby-test-files.yaml}
ainsi que d'autres vérifications
\end{itemize}
\end{frame}

\begin{frame}[fragile=singleslide]{Pas à pas\ldots (2)}
Améliorez le paquet créé :
\begin{itemize}
	\item Exécutez \texttt{debclean} pour nettoyer l'arborescence. Regardez
\texttt{debian/}.
		\hbr
	\item \texttt{changelog} et \texttt{compat} devraient être corrects
		\hbr
	\item Éditez \text{debian/control} : améliorez \texttt{Description}
		\hbr
	\item Écrivez un fichier \texttt{copyright} approprié se basant sur les fichiers
amont
		\hbr
	\item Construisez le paquet
		\hbr
	\item Comparez votre paquet avec le paquet \texttt{ruby-peach} présent dans
l'archive Debian
\end{itemize}
\end{frame}

\subsection{Travaux pratiques nº~5 : module Perl}
\begin{frame}[fragile=singleslide]{Travaux pratiques nº~5 : module Perl}
\begin{enumerate}
	\item Jetez un coup d'œil sur la documentation pour la construction de paquets
Perl :\\
		\begin{itemize}
		\item \url{https://perl-team.pages.debian.net}
      \hbr
		\item \url{https://wiki.debian.org/Teams/DebianPerlGroup}
      \hbr
		\item \texttt{dh-make-perl(1)}, \texttt{dpt(1)} (in the \texttt{pkg-perl-tools}
package)
		\end{itemize}
		\hbr
	\item Créez un paquet source Debian élémentaire à partir du module \texttt{Acme}
de CPAN :\verb|dh-make-perl --cpan Acme|
	\hbr
	\item Améliorez-le pour qu'il devienne un paquet Debian à part entière
\end{enumerate}
\end{frame}

\begin{frame}[fragile=singleslide]{Pas à pas\ldots}
\verb|dh-make-perl --cpan Acme|:
\begin{itemize}
\item Télécharge l'archive de CPAN
\item Crée une archive .orig.tar.gz adéquate, et la décompresse
\item Initialise un paquet source Debian basé sur les métadonnées de CPAN
	\begin{itemize}
		\item Named \texttt{lib\textsl{distname}-perl}
	\end{itemize}
\end{itemize}
\end{frame}

\begin{frame}[fragile=singleslide]{Pas à pas\ldots (2)}
Améliorez le paquet créé :
\begin{itemize}
	\item \texttt{debian/changelog}, \texttt{debian/compat},
\texttt{debian/libacme-perl.docs}, and \texttt{debian/watch} devraient être
corrects
		\hbr
	\item Éditez \text{debian/control} : améliorez \texttt{Description}, et enlevez le
texte à la fin
		\hbr
	\item Éditez \texttt{debian/copyright}: enlevez le premier paragraphe en haut,
ajoutez les années du copyright aux paragraphes
\texttt{Files:\hspace{0.3em}*}
\end{itemize}
\end{frame}


\section*{Traduction}
\begin{frame}{Traduction}
 Ce tutoriel a été traduit de l'anglais par Cédric Boutillier, Jean-Philippe\ Mengual
  et l'équipe francophone de traduction.
 \hbr

 Veuillez signaler toute erreur de traduction ou adresser vos commentaires par
 courrier électronique, à l'adresse
 \href{mailto:debian-l10n-french@lists.debian.org}{\texttt{<debian-l10n-french@lists.debian.org>}}.
\end{frame}
\end{document}