% !TEX root = BuildWithGBP.nw
\part{Veröffentlichen}
\chapter{Vorbereitungen zum Hochladen}
\label{chap:Uploading}

Bisher haben wir uns damit beschäftigt, auf unserem Rechner ein
\texttt{Debian}-Paket zu bauen, wie es auch vom Projekt \texttt{Debian}
bereitgestellt wird.

Nun geht es darum, dass dieses Paket auch hochgeladen \index{Hochladen} 
und damit dem \texttt{Debian}-Projekt zur Verfügung gestellt werden kann.

Die Vorbereitung erfolgt durch die Funktion \textit{PrepareUploading}.

\section{Existiert \textit{debian/changelog}?}

Es wird sicherheitshalber überprüft, ob eine Datei 
\textit{debian/changelog} bereits existiert.

<<PrepareUploading>>=
function PrepareUploading {
    # Called by TaskSelect

    cd ${GitPath}
    
    # Check debian/changelog
    if [ -f debian/changelog ]
    then
        less --LINE-NUMBERS debian/changelog
    else
<<PrepareUploading1>>
@

Ist diese Datei nicht vorhanden, bricht das Programmskript an dieser 
Stelle mit einem entsprechenden Hinweis ab.

<<PrepareUploading1>>=
        whiptail --title "This is the end" \
        --msgbox "No changelog - no upload!" 15 60
        exit
    fi

<<PrepareUploading2>>
@

\begin{figure}[h]
\centering
\includegraphics[width=30em,height=30ex]{Pictures/NoChangelog.png}
\caption{Kein Changelog - kein Hochladen}
\end{figure}

Andernfalls wird der Changelog für eine Veröffentlichung vorbereitet oder
verwandt. Hierzu wird abgefragt, ob der Changelog schon 
veröffentlichungsreif ist.

Dazu muss auf jeden Fall das \enquote{UNRELEASED} durch die jeweilige
Distributionsbezeichnung -- meist \enquote{unstable} -- ersetzt werden.

<<PrepareUploading2>>=
    if ! whiptail --title "Changelog fit for publishing?" --defaultno \
    --yesno "Is the changelog fit for publishing?" --yes-button "Yes" \
    --no-button "No" 15 60
<<PrepareUploading3>>
@

\begin{figure}[h]
\centering
\includegraphics[width=30em,height=30ex]{Pictures/ChangelogFitForPublishing.png}
\caption{Changelog veröffentlichungsreif?}
\end{figure}

Wird die Frage bejaht, wird die Option eröffnet, das Paket nochmal zu 
bauen (Kapitel~\ref{sec:BuildAgain}, Seite~\pageref{sec:BuildAgain}).

\section{\textit{debian/changelog} fertigstellen}

Ist die Datei \textit{debian/changelog} nicht veröffentlichungsreif, wird
sie verbessert. 

Hierzu wird zunächst dazu aufgefordert zu prüfen, ob man im richtigen 
\texttt{Git}-Zweig ist. Mit der Funktion \textit{AskDist} 
(Kapitel~\ref{subsec:IdentifyDist}, Seite~\pageref{subsec:IdentifyDist})
wird ermittelt, welches der aktuelle \texttt{Git}-Zweig und welche
Distribution ihm zugeordnet ist.

Danach wird das Ergebnis angezeigt. Gegebenenfalls kann in einem weiteren 
Terminal der Zweig gewechselt werden.

<<PrepareUploading3>>=
    then
        AskDist
        echo -e "Notice from PrepareUploading: The branch is "${RecentBranch}"\n \
        The distribution is "${RecentBranchD} >> ${log}
        whiptail --title "Please check! (U)" \
        --msgbox "The branch is ${RecentBranch}" 15 60
<<PrepareUploading4>>
@

\begin{figure}[h]
\centering
\includegraphics[width=30em,height=30ex]{Pictures/CheckBranch.png}
\caption{Branch überpüfen}
\end{figure}

Sodann ist gegebenenfalls der Name der Distribution anzugeben, wohin das 
gebaute \texttt{Debian}-Paket hochgeladen werden soll. In der Regel ist 
dies die Distribution \textit{unstable}. 

<<PrepareUploading4>>=
        
        if [ "${RecentBranchD}" = "sid" ]
        then
            distName="unstable"
        elif [ "${RecentBranchD}" = "experimental" ]
        then
            distName="experimental"
        else
            distName=$(whiptail --title "Name of the distribution" \
            --inputbox "Please insert the name of the distribution\n \
            specified in the changelog" \
            --cancel-button "Cancel" 15 60 3>&2 2>&1 1>&3)
        fi
<<PrepareUploading5>>
@

\begin{figure}[h]
\centering
\includegraphics[width=30em,height=30ex]{Pictures/NameOfDistribution.png}
\caption{Name der Distribution eingeben}
\end{figure}

Wird kein Name eingegeben, wird \textit{unstable} als Distribution 
angenommen.

Dann wird nochmal der Name der Distribution mit der Aufforderung zur 
Prüfung angezeigt.

<<PrepareUploading5>>=
        if [ -z "${distName}" ]
        then
            distName="unstable"
        fi
        
        echo -e "Another notice from PrepareUploading:\n \
        The distribution is now "${distName} >> ${log}
        whiptail --title "Please check! (U)" \
        --msgbox "The distribution is ${distName}" 15 60
<<PrepareUploading6>>
@

\begin{figure}[h]
\centering
\includegraphics[width=30em,height=30ex]{Pictures/CheckDistName.png}
\caption{Name der Distribution überprüfen}
\end{figure}

Gerade bei neuen Paketen verwenden die Autoren gerne einen Upload nach 
\textit{experimental}. Für neue Pakete ist nämlich ein 
\textit{Binary}-Upload 
notwendig.

<<PrepareUploading6>>=

        # making debian/changelog fit for publishing
        gbp dch --release --verbose --debian-branch=${RecentBranch} \
        --distribution=${distName} #--commit
<<PrepareUploading8>>
@

Nach der Erstellung des Changelogs für das Release wird zur Kontrolle 
automatisch der Standardeditor geöffnet. Dies kann nicht vom Skript 
beeinflusst werden. 

Diese Anzeige ist auch sinnvoll. Oft sind nämlich doppelte Commit-Einträge 
zu löschen.

<<PrepareUploading8>>=
        git add .
        git commit -a

        whiptail --title "Build again" \
        --msgbox "Now the release will be built another time." 15 60

<<PrepareUploading10>>
@

\begin{figure}[h]
\centering
\includegraphics[width=30em,height=30ex]{Pictures/BuildAgain.png}
\caption{Fürs Release bauen}
\end{figure}

Nun wird das Paket fürs Hochladen ins \texttt{Debian}-Repositorium gebaut.

Das nochmalige Bauen ist notwendig, da die Datei \textit{debian/changelog}
geändert wurde und daher erneut integriert werden muss.

<<PrepareUploading10>>=
        # Building revision
        GpgKeyAvailable
        SBuildOrPBuilder 1
        if [ $gbpq -eq 0 ]
        then
            echo "Package ${SourceName} was built using gbp buildpackage." >> ${log}
        fi
<<PrepareUploading11>>
@

\section{Nochmaliges Bauen?}
\label{sec:BuildAgain}

Hier geht es weiter, wenn die Frage bejaht wird, ob die Datei
\textit{debian/changelog} veröffentlichungsreif ist. Dann wird die
Option eröffnet, das Paket nochmals zu bauen.

Das Bauen erfolgt dann in der soeben beschriebenen Weise.

<<PrepareUploading11>>=
    else
        if whiptail --title "Building another time?" \
        --yesno "Should the release be built another time?\n(Without tagging)" \
        --yes-button "Yes" --no-button "No" 15 60
<<PrepareUploading12>>
@

\begin{figure}[h]
\centering
\includegraphics[width=30em,height=30ex]{Pictures/BuildAgain.png}
\caption{Fürs Release bauen}
\end{figure}

<<PrepareUploading12>>=
        then
            # Building revision
            SBuildOrPBuilder 2
            if [ $gbpq -eq 0 ]
            then
                echo "Package ${SourceName} was built using gbp buildpackage." >> ${log}
            fi
        fi
    fi
}

<<SelectUploadTarget>>
@

\section{Soll ein \texttt{Debdiff} erstellt werden?}

Bevor nach \textit{salsa.debian.org} hochgeladen wird, wird gegebenenfalls
abgefragt, ob ein \textit{debdiff} (Kapitel~\ref{subsec:debdiff},
Seite~\pageref{subsec:debdiff}). erstellt werden soll.

<<TaskSelect9>>=
    if [ ${rcts} -eq 0 ]
    then
        Ask4DebDiff
<<TaskSelect9-1>>
@

Die Abfage erfolgt nur, wenn jenseits vom Zweig \textit{Unstable} paketiert
werden soll (Kapitel~\ref{chap:JenseitsUnstable},
Seite~\pageref{chap:JenseitsUnstable}).

<<Ask4DebDiff>>=
function Ask4DebDiff {
    # Called by TaskSelect

    # Check whether branch is sid
    if [ ${RecentBranch} == "debian/sid" ] || [ ${RecentBranch} == "master" ] || \
       [ ${RecentBranch} == "main" ]
    then
        return
    fi

    # Creating a Debdiff?
    if whiptail --title "DebDiff needed?" \
        --yesno "Do you want to create a debdiff?" \
        --yes-button "Yes" --no-button "No" 15 60
    then
        DebDiff 1
    fi
}

<<TaskSelect>>
@

\begin{figure}[h]
\centering
\includegraphics[width=30em,height=30ex]{Pictures/DebDiffNeeded.png}
\caption{DebDiff benötigt?}
\end{figure}

\chapter{Hochladen auf Git-Repositorien}

Im folgenden Abschnitt aus der Aufgabenauswahl werden zunächst die
Funktionen aufgerufen, um in die Git-Repositorien hochzuladen.

<<TaskSelect9-1>>=
        ##############

        # Pushing git repo
    
        ##############

        Upload2OwnServer
        Upload2Salsa

<<TaskSelect10>>
@


\section{Hochladen nach salsa.debian.org}
\label{sec:SalsaHochladen}

Vor dem Hochladen nach \textit{salsa.debian.org} überprüft das 
Programmskript, ob dort überhaupt schon ein entsprechendes Repositorium
vorhanden ist.

<<Upload2Salsa>>=
function Upload2Salsa {
    # Called by TaskSelect and itself

    # Uploading to Salsa

    if whiptail --title "Upload to salsa.debian.org?" \
    --yesno "Should ${SourceName} be uploaded to Salsa?" \
    --yes-button "Yes" --no-button "No" 15 60
    then
<<Upload2Salsa1>>
@

\begin{figure}[h]
\centering
\includegraphics[width=30em,height=30ex]{Pictures/Upload2Salsa.png}
\caption{Fürs Release bauen}
\end{figure}

<<Upload2Salsa1>>=
        BrowserName=$(echo ${SalsaName} | sed --expression='s/.git$//g')
        BrowserName="https://salsa.debian.org/"${BrowserName}
        wget --spider --verbose --max-redirect=0 \
        --append-output=${log} ${BrowserName}
        if [ $? -ne 0 ]
        then
             whiptail --title "No project found at salsa.debian.org" \
            --msgbox "Please create ${BrowserName} first" 15 60
            echo "No project "${BrowserName}" found at salsa.debian.org" \
            >> ${log}

            if whiptail --title "Done?" \
            --yesno "Created ${BrowserName} on salsa.debian.org?" \
            --yes-button "Yes" --no-button "No" 15 60
            then
                Upload2Salsa
            else
                exit
            fi
        else
<<Upload2Salsa5>>
@

Wenn Patch-Queue-Zweige existieren, können diese vor dem Hochladen nach 
\textit{salsa.debian.org} gelöscht werden.

<<Upload2Salsa5>>=
            set +e
            if echo $(git branch) | grep --quiet 'patch-queue/'
            then
                if whiptail --title "Patch queue branches found:" \
                --yesno "$(git branch | grep 'patch-queue')\n \
                Delete all patch-queue branches?" \
                --yes-button "Yes" --no-button "No" 15 60
<<Upload2Salsa6>>
@

\begin{figure}[h]
\centering
\includegraphics[width=25em,height=30ex]{Pictures/FoundPatchQueueBranches.png} 
\caption{Patch-Queue Zweige gefunden}
\end{figure}

<<Upload2Salsa6>>=
                then
                    git branch --delete --force \
                    $(git branch | grep 'patch-queue')
                fi
            fi
            set -e

            if ! whiptail --title "Last stop before upload!" \
            --yesno "Anything all right?" \
            --yes-button "Yes" --no-button "No" 15 60
<<Upload2Salsa7>>
@

\begin{figure}[h]
\centering
\includegraphics[width=25em,height=30ex]{Pictures/LastStopp.png} 
\caption{Letzter Halt - Alles OK?}
\end{figure}

<<Upload2Salsa7>>=
            then
                exit
            fi
            set +e
            if git remote | grep 'salsa' > /dev/null
            then
                RepoName="salsa"
            else
                RepoA=($(git remote))

                i=0; slct=''
                for element in ${RepoA[*]}
                do
                    slct=$slct' '$i' '${element}' off '
                    i=$(expr $i + 1)
                done

                RepoNr=$(whiptail --title "Select repository" \
                --radiolist "Select one of these repositories" \
                --cancel-button "Exit" 15 60 8 \
                $slct 3>&2 2>&1 1>&3)

                if [ -z "${RepoNr}" ]
                then
                    exit
                else
                    RepoName=${RepoA[${RepoNr}]}
                fi
            fi

            git push --set-upstream ${RepoName} --all >> ${log}
            git push --set-upstream ${RepoName} --tags >> ${log}
            set -e

            echo ${SourceName}" was uploaded to salsa.debian.org." >> ${log}
        fi
    fi
}

<<GettingFingerprint>>
@

\section{Hochladen auf eigenen Git-Server}
\label{sec:HochladenEigenerGitServer}

Das Hochladen auf einen eigenen Git-Server setzt voraus, dass ein solcher 
eingerichtet wurde (Kapitel~\ref{subsec:EigenerGitServer}, 
Seite~\pageref{subsec:EigenerGitServer}).
Ferner ist zuvor sein Name oder seine IP-Adresse einzugeben 
(Kapitel~\ref{sec:NameEigenerGitServer}, 
Seite~\pageref{sec:NameEigenerGitServer}).

<<Upload2OwnServer>>=
function Upload2OwnServer {
    # Called by TaskSelect

    # Uploading to own git server
    if [ -n "$ServerName" ]
    then
        if whiptail --title "Upload to own git server?" \
        --yesno "Should ${SourceName} be uploaded to your own git server?" \
        --yes-button "Yes" --no-button "No" 15 60
        then
            git push --set-upstream home --all >> ${log}
            git push --set-upstream home --tags >> ${log}

            echo ${SourceName}" was uploaded to your git server." >> ${log}
        fi
    fi
}

<<Upload2Salsa>>
@

\chapter{Paket(e) hochladen}
\label{chap:UploadPackage}

In der Funktion \textit{TaskSelect} (Aufgabenauswahl) werden auch die 
Funktionen zum Hochladen der Pakete aufgerufen.

<<TaskSelect10>>=
        ##############

        # Uploading packages

        ##############

        SelectUploadTarget
        CreateSignature
        UploadUsingDput
        Upload2PeopleDO
        UploadLocal
<<TaskSelect11>>
@

Wenn die Funktionen \textit{CreateNewBranch} 
(Kapitel~\ref{sec:NeuenBranchErstellen}, Seite~\pageref{sec:NeuenBranchErstellen}), 
\textit{SelectBranch} (Kapitel~\ref{sec:AuswahlGitBranch}, 
Seite~\pageref{sec:AuswahlGitBranch}) oder \textit{OwnServer}
(Kapitel~\ref{sec:NameEigenerGitServer}, 
Seite~\pageref{sec:NameEigenerGitServer}) aufgerufen wurden, wird die 
Konfigurationsdatei erneut zur Bearbeitung 
angezeigt (Kapitel~\ref{sec:ConfigFileLaden}, 
Seite~\pageref{sec:ConfigFileLaden} und anschließend die Aufgabenauswahl 
erneut aufgerufen.

<<TaskSelect11>>=
    else
        ConfigFileLEC
        CommonTasks
    fi
}

<<StartTasks>>
@

\section{Auswahl des Zielrepositoriums}

Vor dem Hochladen ist das Zielrepositorium auszuwählen. Dabei wird ein
\textit{Non"=Maintainer"=Upload} wie ein Repositorium behandelt.

<<SelectUploadTarget>>=
function SelectUploadTarget {
    # Called by TaskSelect Upload2FtpMaster

    # Select upload target
    Upl=$(whiptail --title "Uploading?" \
    --radiolist "Should the package be uploaded to ftp-master,\n \
    people.d.o or mentors.debian.net?" 15 60 6\
      "0" "No" off \
      "1" "ftp-master" on \
      "2" "people.d.o" off \
      "3" "Mentors" off \
      "4" "Non-Maintainer-Upload" off \
      "5" "Local repository" off --cancel-button "Exit" 3>&2 2>&1 1>&3)

<<SelectUploadTarget1>>
@

\begin{figure}[h]
\centering
\includegraphics[width=30em,height=30ex]{Pictures/UploadTarget.png}
\caption{Ziel des Uploads.}
\end{figure}

Wird \enquote{No} oder \enquote{Cancel} ausgewählt, wird das Programm beendet.

<<SelectUploadTarget1>>=
    # The order of the conditions is important!
    # 'Cancel' results an empty variable
    if [ -z ${Upl} ] || [ ${Upl} -eq 0 ]
    then
        exit
    fi

<<SelectUploadTarget2>>
@

Über den Wert, der der Variablen \textit{Upl} zugewiesen wird, wird der
weitere Ablauf gesteuert.

<<SelectUploadTarget2>>=
    case "${Upl}" in
     1) Upltext="ftp-master";;
     2) Upltext="people.d.o";;
     3) Upltext="Mentors";;
     4) Upltext="delayed";;
     5) Upltext="local repository";;
    esac

<<SelectUploadTarget3>> 
@

Im Folgenden wird nun mit der Funktion \textit{SelectChangesFile}
(Kapitel~\ref{sec:SelectChangesFile},
Seite~\pageref{sec:SelectChangesFile}) die \textit{*.changes}-Datei des
hochzuladenen Paketes ausgewählt.

<<SelectUploadTarget3>>=

    cd ${PrjPath}

    # Select package
    SelectChangesFile "Upload" # String will be found in ${1}
    UplPaket=${changesa[$paket]}

    # Version2=$(echo ${UplPaket} | sed --expression="s/^[a-z\-]*_//" | \
    # sed --expression="s/-.*$//")
    # SourceName1=$(echo ${UplPaket} | sed --expression="s/_.*//1")
    # OrigPaket=${SourceName1}"_"${Version2}".orig"

<<SelectUploadTarget4>>
@

Vor dem Hochladen erfolgt noch eine Kontrollfrage, ob das ausgewählte Paket zum ausgewählten Ziel hochgeladen werden soll. Dabei wird zum ersten Mal
der Wert \textit{Upltext} benötigt.

<<SelectUploadTarget4>>= 
    # Final question before uploading starts
    if [ ${Upl} -ne 4 ]
    then
        if ! whiptail --title "Upload to ${Upltext}?" \
        --yesno "Do you want to upload ${UplPaket} to ${Upltext}." \
        --yes-button "Yes" --no-button "Exit" 15 60
<<SelectUploadTarget5>>
@

\begin{figure}[h]
\centering
\includegraphics[width=30em,height=30ex]{Pictures/UploadToTarget.png}
\caption{Ist das angegebene Ziel des Uploads korrekt?}
\end{figure}

<<SelectUploadTarget5>>=
        then
            whiptail --title "Bye" --msgbox "Bye" 15 60
<<SelectUploadTarget6>>
@

\begin{figure}[h]
\centering
\includegraphics[width=30em,height=30ex]{Pictures/Bye.png}
\caption{Bye}
\end{figure}

<<SelectUploadTarget6>>=
            exit
        fi
    fi

    echo "${UplPaket} should be uploaded to ${Upltext}." >> ${log}
}

<<Upload2OwnServer>>
@

\section{Signatur erzeugen}

Vor dem Hochladen muss das Paket signiert werden.

Die Funtion \textit{CreateSignature} erzeugt die erforderlichen Signaturen 
mittels \textit{debsign}. \textit{debsign} signiert ein Debian-.changes- 
und -.dsc-Dateipaar mittels GnuPG. Dazu muss der \texttt{GnuPG}-Schlüssel
zur Verfügung stehen (Kapitel~\ref{sec:KeyAvailable},
Seite~\pageref{sec:KeyAvailable}).

Wurde die Datei \textit{*.changes} bereits signiert, Erscheint auf der
Konsole folgende Meldung:

\begin{verbatim}
    The .changes file is already signed.
    Would you like to use the current signature? [Yn]
\end{verbatim}

Im Falle des Fehlschlagens wird eine Wiederholung angeboten.

<<CreateSignature>>=
function CreateSignature {
    # Called by TaskSelect Upload2FtpMaster and itself

    # Key available?
    GpgKeyAvailable

    # Signature using debsign
    set +e
    debsign -k${fipr} ${UplPaket}
    if [ $? -ne 0 ]
    then
        if whiptail --title "Signing failed!" \
        --yesno "Signature failed - Retry?" \
        --yes-button "Yes" --no-button "Exit" 15 60
<<CreateSignatur3>>
@

\begin{figure}[h]
\centering
\includegraphics[width=30em,height=30ex]{Pictures/SignatureExists.png}
\caption{Signieren erfolgreich?}
\end{figure}

<<CreateSignatur3>>=
        then
            CreateSignature
        else
            exit
        fi
    fi
	set -e
    echo "${UplPaket} was signed" >> ${log}
}

<<Upload2Mentors>>
@

\section{Hochladen mit dput}
\label{sec:DputHochladen}

In der Funktion \textit{UploadUsingDput} erfolgt nur die Weichenstellung,
ob das Paket mittels \textit{dput} zu den Ftp-Mastern
(Kapitel~\ref{sec:UploadFtpMaster}, Seite~\pageref{sec:UploadFtpMaster})
oder nach \url{mentors.debian.net} (Kapitel~\ref{sec:UploadMentors},
Seite~\pageref{sec:UploadMentors}) hochgeladen werden soll.

<<UploadUsingDput>>=
function UploadUsingDput {
    # Called by TaskSelect Upload2FtpMaster

    # Uploading using dput

    cd ${PrjPath}/
    if [ ${Upl} -eq 3 ]
    then
        Upload2Mentors
    elif [ ${Upl} -eq 1 ] || [ ${Upl} -eq 4 ]
    then
        Upload2FtpMaster
    fi
}

<<UploadFilesSelect>>
@

\section{Nach FTP-Master hochladen}
\label{sec:UploadFtpMaster}

Die Pakete werden regelmäßig nach \textit{ftp-master} hochgeladen, um sie
durch das \texttt{Debian}-Projekt zu veröffentlichen. Andere
Veröffentlichungswege sind eher die Ausnahme.

<<Upload2FtpMaster>>=
function Upload2FtpMaster {
    # Called by UploadUsingDput

    # repeat question
    if whiptail --title "Last exit" \
    --yesno "Should the package be uploaded to ftp-master?" \
    --yes-button "Yes" --no-button "Exit" 15 60
<<Upload2FtpMaster1>>
@

\begin{figure}[h]
\centering
\includegraphics[width=25em,height=30ex]{Pictures/UploadFtpMaster.png}
\caption{Upload to FTP-Master - OK?}
\end{figure}

<<Upload2FtpMaster1>>=
    then
        set +e
        # Checking whether the .changes file is the right one for the upload target
        sourceFlag=$(echo ${UplPaket} | grep --count '_source.')
        expFlag=$(grep --line-number ') experimental; urgency=' ${GitPath}/debian/changelog \
        | grep '^1:')
        set -e
        echo -e "${UplPaket}:\n${expFlag}\nsourceFlag: ${sourceFlag}" >> ${log}
        # Strip line to isolate release
        expFlag=$(echo ${expFlag} | sed --expression='s/^.*) //' | \
        sed --expression='s/; .*$//')

        if [ -z "${expFlag}" ]
        then
            if [ ${sourceFlag} -eq 0 ]
            then
                if whiptail --title "Uploading?" \
                --yesno "Do you really want to upload a binary package\n \
                to ftp-master?" --yes-button "Yes" --no-button "No" 15 60
                
<<Upload2FtpMaster2>>
@

\begin{figure}[h]
\centering
\includegraphics[width=25em,height=30ex]{Pictures/UploadBinaryFtpMaster.png}
\caption{Soll ein Binär-Paket auf FTP-Master hochgeladen werden?}
\end{figure}

<<Upload2FtpMaster2>>=
                then
                    Dput2FtpMaster
                else
                    echo "Next try to upload"  >> ${log}
                    SelectUploadTarget
                fi
            else
                Dput2FtpMaster
            fi
        else
            if [ $sourceFlag -ge 1 ]
            then
                if whiptail --title "Uploading?" \
                --yesno "Do you really want to upload a source package\n \
                to experimental?" --yes-button "Yes" --no-button "No" 15 60

<<Upload2FtpMaster3>>
@

\begin{figure}[h]
\centering
\includegraphics[width=25em,height=30ex]{Pictures/UploadSourceExpFtpMaster.png}
\caption{Wirklich nach Experimental hochladen?}
\end{figure}

<<Upload2FtpMaster3>>=

                then
                    Dput2FtpMaster
                else
                    echo "Next try to upload"  >> ${log}
                    SelectUploadTarget
                    CreateSignature
                    UploadUsingDput
                fi
            else
                Dput2FtpMaster
            fi
        fi
    fi
}

<<UploadUsingDput>>
@

In der folgenden Funktion erfolgt das Hochladen nach FTP-Master.

<<Dput2FtpMaster>>=
function Dput2FtpMaster {
    # Called by Upload2FtpMaster

    if whiptail --title "Simulate uploading?" \
    --yesno "Should the upload to ftp-master be simulated?" \
    --yes-button "Yes" --no-button "No" 15 60

<<Dput2FtpMaster1>>
@

\begin{figure}[h]
\centering
\includegraphics[width=25em,height=30ex]{Pictures/UploadFtpMasterSimulated.png}
\caption{Soll das Hochladen auf FTP-Master simuliert werden?}
\end{figure}

<<Dput2FtpMaster1>>=
    then
        dput --simulate ftp-master ${UplPaket}
        echo
        echo "After reading press RETURN!"
        read x
    fi

    if whiptail --title "Uploading to FTP-Master?" \
    --yesno "Everything fine?\n\n \
    Should the package be uploaded to ftp-master now?" \
    --yes-button "Yes" --no-button "No" 15 60

<<Dput2FtpMaster2>>
@

\begin{figure}[h]
\centering
\includegraphics[width=25em,height=30ex]{Pictures/EverythingFine.png}
\caption{Ist alles ok mit dem Hochladen?}
\end{figure}

<<Dput2FtpMaster2>>=
    then
        if [ ${Upl} -eq 1 ]
        then
            dput ftp-master ${UplPaket}
            echo "${UplPaket} was uploaded to ${Upltext}." >> ${log}
        else
            Dput2NMU
        fi
    fi
}

<<Upload2FtpMaster>>
@

Dieses Paket landet zunächst auf
\url{https://incoming.debian.org/debian-buildd/pool/main/} 
bis es vom Build-Daemon (buildd) gebaut und zum Herunterladen zur 
Verfügung gestellt wird.

\subsection{Zurückweisung eines Paketes}

Wenn ein Paket von den FTP-Mastern zurückgewiesen wird, sollte beim
anschießenden Hochladen des korrigierten Paketes die Revisionsnummer
nicht erhöht werden.

Dazu muss die Datei \textit{<PaketName>\_<Version>\_source.ftp-master.upload}
vorher im Projektverzeichnisentfernt werden.

\section{Nach mentors.debian.net hochladen}
\label{sec:UploadMentors}

<<Upload2Mentors>>=
function Upload2Mentors {
    # Called by UploadUsingDput

    if whiptail --title "Simulate uploading?" \
    --yesno "Should the upload to Mentors be simulated?" \
    --yes-button "Yes" --no-button "No" 15 60
    then
        dput --simulate mentors ${UplPaket}
        echo
        echo "After reading press RETURN!"
        read x
    fi

    # repeat question 
    if whiptail --title "Uploading?" \
    --yesno "Should the package be uploaded to Mentors?" \
    --yes-button "Yes" --no-button "No" 15 60
    then
        dput mentors ${UplPaket}
        echo "${UplPaket} was uploade to ${Upltext}." >> ${log}
    fi
}

<<Dput2NMU>>
@

\section{Als \textit{Non-Maintainer-Upload} hochladen}

Im Rahmen der Ausbesserung veröffentlichungskritischer Fehler durch
Andere als dem Paket-Maintainer ist es üblich, dem Paket-Maintainer 
noch eine gewisse Zeit zu lassen, selber das Problem zu lösen.

<<Dput2NMU>>=
function Dput2NMU {
    # Called by Dput2FtpMaster

    DelayDays=$(whiptail --title "Non-Maintainer-Upload" \
    --radiolist "Days for delay?" 15 60 5 \
    "0" " 5 days of delay" off \
    "1" "10 days of delay" on \
    "2" "15 days of delay" off --cancel-button "Exit" 3>&2 2>&1 1>&3)

<<Dput2NMU1>>
@

\begin{figure}[h]
\centering
\includegraphics[width=30em,height=30ex]{Pictures/DaysOfDelay.png}
\caption{Tage der Verzögerung}
\end{figure}

Es kann ausgewählt werden, wie viele Tage dem Paket-Maintainers zur
eigenen Lösung des Problems verbleiben sollen. 

<<Dput2NMU1>>=    
    if [ -z ${DelayDays} ]
    then
        exit
    fi
    
    case "${DelayDays}" in
        0) DelDays=5;;
        1) DelDays=10;;
        2) DelDays=15;;
    esac
    
    dput --delayed ${DelDays} ftp-master ${UplPaket}
}

<<Dput2FtpMaster>>
@

\section{Hochladen nach \textit{people.debian.org}}

<<Upload2PeopleDO>>=
function Upload2PeopleDO {
    # Called by TaskSelect

    if [ ${Upl} -eq 2 ]
    then
        # For people.d.o you can not use dput
        if whiptail --title "Archive on people.d.o" \
        --yesno "Does the directory public_html/${OrigName} \
        already exsist at people.d.o?\n \
        If not you have to enter the following commands\n \
        in a separate terminal:\n\n \
        ssh <user>@people.debian.org\n \
        mkdir --parents public_html/${OrigName}" \
        --yes-button "Yes" --no-button "No" 15 60
        then
            UploadFilesSelect
<<Upload2PeopleDO3>>
@

<<UploadFilesSelect>>=
function UploadFilesSelect {
    # Called by Upload2PeopleDO UploadLocal

    set +e
    UplFL=$(cat ${UplPaket} | grep --after-context=10 'Files: *')
    UplFL1=$(echo ${UplFL} | sed --expression='s/Files: //')
    i=1
    while [ $i -lt 6 ]
    do
        c=$(expr ${i} \* 5)
        UplFL2=${UplFL2}" "$(echo $UplFL1 | cut --delimiter=" " -f${c})
        i=$(expr ${i} + 1)
    done
    set -e
}

<<Upload2PeopleDO>>
@

<<Upload2PeopleDO3>>=
            if whiptail --title "Upload file?" \
            --yesno "Should the following files\n${UplFL2}\n \
            have to be uploaded?" --yes-button "Yes" \
            --no-button "No" 15 60
            then
                if [ -z "${pdoaccount}" ]
                then
                    pdoaccount=$(whiptail --title "Account at people.debian.org" \
                    --inputbox "Please insert the name of your account on\n \
                     people.debian.org" \
                     --cancel-button "Cancel" 15 60 3>&2 2>&1 1>&3)
                    if [ -z "${pdoaccount}" ]
                    then
                        echo "Please insert the name of your account on\n \
                        people.debian.org"
                        read pdoaccount
                    fi
                    changeflag=1
                fi

                if ! whiptail --title "Account name" \
                --yesno "The name of your account on people.debian.org:\n \
                ${pdoaccount}" --yes-button "Yes" --no-button "No" 15 60
                then
                    pdoaccount=$(whiptail --title " Account name" \
                    --inputbox "Name of your account on people.debian.org:" \
                    --cancel-button "Cancel" 15 60 3>&2 2>&1 1>&3)
                    if [ -z "${pdoaccount}" ]
                    then
                        echo "Please insert the name of your account on\n \
                        people.debian.org"
                        read pdoaccount
                    fi
                    changeflag=1
                fi

                if [ $changeflag -eq 1 ]
                then
                    echo 'pdoaccount='${pdoaccount} >> ${ConfigPath}${OrigName}
                    changeflag=0
                fi

                cd ${ProjectPath}/${OrigName}
                if scp -p ${UplFL2} \
                ${pdoaccount}@people.debian.org:/home/${pdoaccount}/public_html/${OrigName}
                then
                    echo "${UplFL2} were uploaded to p.d.o." >> ${log}
                else
                    echo "Something went wrong while uploading to p.d.o." >> ${log}
                    echo "Tried to execute this command:" >> ${log}
                    echo  "scp -p "${UplFL2}" "${pdoaccount}"@people.debian.org:/home/"\
                    ${pdoaccount}"/public_html/"${OrigName} >> ${log}
                fi
                pdoarchivetext="If the archive on people.d.o should be\n \
                used too, you have to enter the following commands:\n \
                ssh <user>@people.debian.org\n \
                cd public_html/${OrigName}\n \
                apt-ftparchive packages . > Packages\n \
                apt-ftparchive sources . > Sources\n \
                cat Packages | gzip -c > Packages.gz\n \
                cat Sources | gzip -c > Sources.gz\n \
                apt-ftparchive release . > Release"

                if whiptail --title "Archive on people.d.o" \
                --yesno "${pdoarchivetext}\n\n \
                Do you like to copy and paste these commands?" \
                --yes-button "Yes" --no-button "No" 15 60
                then
                    echo -e $pdoarchivetext
                    echo -e "\nPlease press any key to continue!"
                    read x
                fi
            fi
        fi
    fi
}

<<UpdateLocalRepo>>
@

\section{Lokales Repositorium}

Es kommt immer wieder vor, dass Pakete gebaut werden müssen, die für das
eigentliche Projekt als Abhängigkeiten benötigt werden. Um die Zeit für
den Gang durch die New-Queue zu überbrücken, können diese auch lokal
für das Bauen in der \textit{chroot} bereitgestellt werden.

<<UploadLocal>>=
function UploadLocal {
    # Called by TaskSelect
    if [ ${Upl} -eq 5 ]
    then
        # Provide for local chroot
        UploadFilesSelect
        if whiptail --title " Files Uploaded?" \
        --yesno "Should the following files\n \
        ${UplFL2}\nhave to be uploaded?" 15 60
        then
            cd ${ProjectPath}/${OrigName}
            sudo cp ${UplFL2} /var/local/repository
            UpdateLocalRepo
        fi
    fi
}

<<ChangeEntry>>
@

Die folgende Funktion gibt es bereits als Shell-Skript unter
\textit{/usr/local/bin/LocalNewRepo}.

<<UpdateLocalRepo>>=
function UpdateLocalRepo {
    # Called by UploadLocal
    cd /var/local/repository

    # Make package archives writable
    # (not only for root)
    sudo chmod o+w Packages
    sudo chmod o+w Sources
    sudo chmod o+w Packages.gz
    sudo chmod o+w Sources.gz
    sudo chmod o+w Release

    # Use apt-ftparchive to update package archives
    sudo apt-ftparchive packages . > Packages &&
    sudo apt-ftparchive sources . > Sources &&
    sudo cat Packages | gzip -c > Packages.gz &&
    sudo cat Sources | gzip -c > Sources.gz &&
    sudo apt-ftparchive release . > Release

    # Reset rights
    sudo chmod o-w Packages
    sudo chmod o-w Sources
    sudo chmod o-w Packages.gz
    sudo chmod o-w Sources.gz
    sudo chmod o-w Release
}

<<UploadLocal>>
@

In die \textit{Chroot-Umgebung}, hier \textit{/var/cache/pbuilder/base.cow},
wird in die Datei \textit{/etc/apt/sources.list} folgendes eingefügt:

\begin{verbatim}
deb [trusted=yes] file:///var/local/repository ./
deb-src [trusted=yes] file:///var/local/repository ./
\end{verbatim}