Vous avez reçu un message "Your GitLab account has been locked ..." ? Pas d'inquiétude : lisez cet article https://docs.gricad-pages.univ-grenoble-alpes.fr/help/unlock/

Commit 6a7b4739 authored by Grégory Mounié's avatar Grégory Mounié
Browse files

gitlabisation/mintedisation

déclinaison en utilisant gitlab
parent 5abaa760
......@@ -2,7 +2,7 @@
\usepackage{header}
\newcommand{\annee}{2017}
\newcommand{\annee}{2021}
\date{\annee}
\author{Sylvain Bouveret, Grégory Mounié}
......@@ -47,80 +47,45 @@ quelconque de coéquipiers.
La première étape, sur votre PC, est de construire d'abord un dépôt
minimaliste. Ce dépôt sera copié, plus tard, sur
\lstinline{depots.ensimag.fr}.
\mintinline{sh}{depots.ensimag.fr}.
\textit{Alice} crée sur sa machine le dépôt local initial.
\begin{alice}
mkdir alice-et-bob
cd alice-et-bob
git init .
mon_editeur_prefere fichier.txt # mettre quelques lignes
git add fichier.txt
git commit
\end{alice}
\begin{minted}{console}
alice@laptop1$ mkdir alice-et-bob
alice@laptop1$ cd alice-et-bob
alice@laptop1$ git init .
alice@laptop1$ mon_editeur_prefere fichier.txt # mettre quelques lignes
alice@laptop1$ git add fichier.txt
alice@laptop1$ git commit
\end{minted}
À chaque étape, pensez à afficher le graphe de commit pour en suivre
l'évolution, soit en mode texte avec~:
\begin{lstlisting}
git log --all --graph --oneline
\end{lstlisting}
\begin{minted}{console}
$ git log --all --graph --oneline
\end{minted}
soit en mode graphique avec~:
\begin{lstlisting}
gitk --all
\end{lstlisting}
\begin{minted}{console}
$ gitk --all
\end{minted}
Suivant les modifications que vous ferez à \texttt{fichier.txt}, il
faudra peut-être aussi gérer quelques conflits.
\subsection{Créer deux dépôts vides sur {\em depots.ensimag.fr}}
\textit{Bob} va, lui, créer deux dépôts vides sur la machine {\em
depots.ensimag.fr}. Il faut dans un premier temps ouvrir un shell
sur cette machine avec ssh~:
\begin{bob}
ssh depots.ensimag.fr
\end{bob}
Si votre mot de passe n'est pas reconnu, rendez-vous sur la page
\url{https://intranet.ensimag.fr/passwords/} et modifiez ou re-validez
votre mot de passe (vous devriez avoir une case « Serveur
'depots.ensimag.fr' », gardez-la cochée), puis ré-essayez.
On commence par créer deux répertoires, et on donne les droits aux
autres coéquipiers via les ACLs (Access Control Lists), en utilisant
le script \texttt{autoriser-equipe} spécifique à l'Ensimag~:
\begin{bob}
cd /depots/ø\anneeø/
mkdir alice-et-bob-public
mkdir alice-et-bob-dev
chmod 700 alice-et-bob-public
chmod 700 alice-et-bob-dev
autoriser-equipe alice-et-bob-public/ alice
autoriser-equipe alice-et-bob-dev/ alice
\end{bob}
Il faut ici préciser les logins de tous les coéquipiers, donc si l'équipe est
constituée des utilisateurs unix \texttt{alice}, \texttt{bob}, \texttt{charlie}
et \texttt{dave}, on entrera la commande
\begin{bob}
autoriser-equipe alice-et-bob/ bob charlie dave
\end{bob}
Les noms d'utilisateurs (login) sont ceux sur \texttt{depots.ensimag.fr},
même si les utilisateurs travaillent avec un autre nom sur leur
machine personnelle.
On peut maintenant créer les deux dépôts vides partagés à l'intérieur de ces
répertoires~:
\begin{bob}
cd alice-et-bob-public/
git init --shared --bare projetc.git
cd ..
cd alice-et-bob-dev/
git init --shared --bare projetc.git
\end{bob}
\subsection{Créer deux dépôts vides sur \texttt{gitlab.ensimag.fr}}
\textit{Bob} va, lui, créer deux dépôts vides sur
\texttt{gitlab.ensimag.fr}.
Référez vous au TP1 pour créer le groupe de développeurs, nommé en
fonction de vos login, comme par exemple \verb!alice_bob!, si il
n'existe pas déjà, et deux projets vides dans ce groupe.
Les deux projets se nommeront:
\begin{enumerate}
\item \texttt{projet2-public}
\item \texttt{projet2-dev}
\end{enumerate}
\subsection{Ajouter deux sources distantes (remote) et y
pousser le code de départ}
......@@ -128,25 +93,25 @@ git init --shared --bare projetc.git
\textit{Alice} ajoute deux sources distantes (remote) à son dépôt et
pousse sa version initiale dans les deux dépôts.
\begin{alice}
cd alice-et-bob
git remote add origin ssh://alice@depots.ensimag.fr/depots/ø\anneeø/alice-et-bob-public/projetc.git
git remote add dev ssh://alice@depots.ensimag.fr/depots/ø\anneeø/alice-et-bob-dev/projetc.git
git remote -v
git push origin master
git push dev master
\end{alice}
\begin{minted}{console}
alice@laptop1$ cd alice-et-bob
alice@laptop1$ git remote add origin ssh://git@gitlab.ensimag.fr/alice_bob/projet2-public.git
alice@laptop1$ git remote add dev ssh://git@gitlab.ensimag.fr/alice_bob/projet2-dev.git
alice@laptop1$ git remote -v
alice@laptop1$ git push origin master
alice@laptop1$ git push dev master
\end{minted}
Maintenant, \textit{Bob} peut cloner un des deux dépôts et ajouter
l'autre source, lui aussi.
\begin{alice}
git clone ssh://bob@depots.ensimag.fr/depots/ø\anneeø/alice-et-bob-public/projetc.git
cd projetc
git remote -v
git remote add dev ssh://bob@depots.ensimag.fr/depots/ø\anneeø/alice-et-bob-dev/projetc.git
git remote -v
\end{alice}
\begin{minted}{console}
bob@laptop2$ git clone ssh://git@gitlab.ensimag.fr/alice_bob/projet2-public.git
bob@laptop2$ cd projet2-public
bob@laptop2$ git remote -v
bob@laptop2$ git remote add dev ssh://git@gitlab.ensimag.fr/alice_bob/projet2-dev.git
bob@laptop2$ git remote -v
\end{minted}
\subsection{Ajouter des tags sur la version «master»}
......@@ -156,49 +121,49 @@ branche «master». Elle devra écrire un message associé au tag
de création, l'identité du créateur, et éventuellement sa signature
GnuPG.
\begin{alice}
git tag -a v0.0
\end{alice}
\begin{minted}{console}
alice@laptop1$ git tag -a v0.0
\end{minted}
Mais ce tag n'existe encore que localement. \textit{Alice} pousse le tag
dans les deux dépôts. Elle peut le faire en poussant uniquement le
tag, ou en poussant tous les tags.
\begin{alice}
git push origin v0.0
git push --tags dev
\end{alice}
\begin{minted}{console}
alice@laptop2$ git push origin v0.0
alice@laptop2$ git push --tags dev
\end{minted}
\textit{Bob} récupère alors le tag de manière implicite lorsqu'il fait un
git pull. Cela ne fonctionne de manière implicite que pour les tags
concernant des objets présents ou tirés dans le dépôt de \textit{Bob}.
\begin{bob}
git pull
\end{bob}
\begin{minted}{console}
bob@laptop2$ git pull
\end{minted}
\textit{Bob} crée un second commit en modifiant \texttt{fichier.txt} et
ajoute le tag annoté \texttt{v1.0}. Il pousse sa modification et le
tag dans les deux dépôts.
\begin{bob}
mon_editeur_prefere fichier.txt
git add -p fichier.txt
git commit
git tag -a v1.0
git push --tags dev
git push --tags
git push
git push dev
\end{bob}
\begin{minted}{console}
bob@laptop2$ mon_editeur_prefere fichier.txt
bob@laptop2$ git add -p fichier.txt
bob@laptop2$ git commit
bob@laptop2$ git tag -a v1.0
bob@laptop2$ git push --tags dev
bob@laptop2$ git push --tags
bob@laptop2$ git push
bob@laptop2$ git push dev
\end{minted}
Le dépôt public «origin» de \textit{Bob} est son dépôt par défaut.
\textit{Alice} peut maintenant le récupérer. Pour ce faire, elle va
indiquer «origin» comme dépôt par défaut de sa branche «master».
\begin{alice}
git branch --set-upstream-to=origin/master master
git pull
\end{alice}
\begin{minted}{console}
alice@laptop1$ git branch --set-upstream-to=origin/master master
alice@laptop1$ git pull
\end{minted}
Elle a noté que l'étiquette «remote/dev/master» est toujours sur le
premier commit.
......@@ -206,28 +171,29 @@ premier commit.
Pour faciliter la maintenance et le développement, {\em Alice} ajoute
une branche «develop».
\begin{alice}
git checkout -b develop
git branch
\begin{minted}{shell-session}
alice@laptop1$ git checkout -b develop
alice@laptop1$ git branch
* develop
master
\end{alice}
\end{minted}
puis elle ajoute un commit sur cette branche et la pousse dans
«dev». Par défaut, Git pousse la branche courante. Elle en profite pour
indiquer à Git que c'est «dev» qui sera le dépôt par défaut où pousser
cette branche
\begin{alice}
mon_editeur_prefere fichier.txt
git add -p
git commit
git push --set-upsteam dev
\end{alice}
\begin{minted}{console}
alice@laptop1$ mon_editeur_prefere fichier.txt
alice@laptop1$ git add -p
alice@laptop1$ git commit
alice@laptop1$ git push --set-upsteam dev
\end{minted}
{\em Bob} récupère la branche \texttt{develop} et bascule sa
position courante (HEAD) dessus.
\begin{bob}
git pull dev
\end{bob}
\begin{minted}{console}
bob@laptop2$ git pull dev
\end{minted}
Un «pull» c'est deux opérations: un «fetch» qui récupère les nouvelles
informations du dépôt, ici, la branche «develop» et son commit, et un «merge».
......@@ -235,9 +201,9 @@ informations du dépôt, ici, la branche «develop» et son commit, et un «merg
Git vous indique que comme la branche «master» n'est pas configurée
pour suivre «dev» (elle est configurée pour suivre «origin»), il faut
préciser la branche pour le «merge».
\begin{bob}
git checkout develop
\end{bob}
\begin{minted}{console}
bob@laptop2$ git checkout develop
\end{minted}
Si tout va bien, Git indique que la branche est configurée pour suivre
l'évolution de la branche de même nom sur «dev».
......@@ -250,44 +216,44 @@ est bien sur la branche «develop». Il ajoute une branche
(«topic1»), code la fonctionnalité et la publie dans
«dev».
\begin{bob}
git status
\begin{minted}{console}
bob@laptop2$ git status
On branch develop
Your branch is up to date with 'dev/develop'.
...
git checkout -b topic1
mon_editeur_prefere fichier.txt
git add -p
git commit
git push --set-upstream dev topic1
\end{bob}
bob@laptop2$ git checkout -b topic1
bob@laptop2$ mon_editeur_prefere fichier.txt
bob@laptop2$ git add -p
bob@laptop2$ git commit
bob@laptop2$ git push --set-upstream dev topic1
\end{minted}
\textit{Alice} veut implanter elle-aussi implanter une nouvelle
fonctionnalité. Elle le fait dans la branche «topic2» qui part de
«develop». Elle enregistre elle-aussi son commit et le publie dans
«dev».
\begin{alice}
git status
\begin{minted}{console}
alice@laptop1$ git status
On branch develop
Your branch is up to date with 'dev/develop'.
...
git checkout -b topic2
mon_editeur_prefere fichier.txt
git add -p
git commit
git push --set-upstream dev topic2
\end{alice}
alice@laptop1$ git checkout -b topic2
alice@laptop1$ mon_editeur_prefere fichier.txt
alice@laptop1$ git add -p
alice@laptop1$ git commit
alice@laptop1$ git push --set-upstream dev topic2
\end{minted}
Après l'avoir testé rigoureusement \textit{Bob} veut fusionner «topic1»
dans «develop».
\begin{bob}
git checkout develop
git merge topic1
git push
gitk --all
\end{bob}
\begin{minted}{console}
bob@laptop2$ git checkout develop
bob@laptop2$ git merge topic1
bob@laptop2$ git push
bob@laptop2$ gitk --all
\end{minted}
Regardez attentivement le graphe de commit. Git n'a pas créé de
commit pour ce merge. Il a juste déplacé la tête. Le terme Git
......@@ -299,18 +265,18 @@ un commit dans la branche «topic1» mais elle veut garder une trace de
la fusion. Elle utilise l'option \texttt{--no-ff} lors du merge. Elle
devra aussi mettre à jour sa branche «develop» avant.
\begin{alice}
git fetch dev
git checkout topic1
mon_editeur_prefere fichier.txt
git add -p
git commit
git checkout develop
git pull
git merge --no-ff topic1
git push
gitk --all
\end{alice}
\begin{minted}{console}
alice@laptop1$ git fetch dev
alice@laptop1$ git checkout topic1
alice@laptop1$ mon_editeur_prefere fichier.txt
alice@laptop1$ git add -p
alice@laptop1$ git commit
alice@laptop1$ git checkout develop
alice@laptop1$ git pull
alice@laptop1$ git merge --no-ff topic1
alice@laptop1$ git push
alice@laptop1$ gitk --all
\end{minted}
Cette fois-ci, Git a demandé un message de
merge et a créé un commit supplémentaire.
......@@ -327,14 +293,14 @@ branche sur la nouvelle version de «develop». Il aura peut-être à
gérer des conflits. Il faudra aussi faire un pull (pour le
merge) après le rebase avant de pouvoir faire le push.
\begin{bob}
git fetch dev
git checkout topic2
git rebase develop
git pull
git push
gitk --all
\end{bob}
\begin{minted}{console}
bob@laptop2$ git fetch dev
bob@laptop2$ git checkout topic2
bob@laptop2$ git rebase develop
bob@laptop2$ git pull
bob@laptop2$ git push
bob@laptop2$ gitk --all
\end{minted}
\subsection{La cachette}
......@@ -350,15 +316,15 @@ Elle va donc sauvegarder le travail en cours dans la cachette (stash),
pour repartir du dernier commit et elle le reprendra après la
correction du bug.
\begin{alice}
git checkout topic2
git pull
mon_editeur_prefere fichier.txt # modification incomplète
git status
git stash
git status
git stash list
\end{alice}
\begin{minted}{console}
alice@laptop1$ git checkout topic2
alice@laptop1$ git pull
alice@laptop1$ mon_editeur_prefere fichier.txt # modification incomplète
alice@laptop1$ git status
alice@laptop1$ git stash
alice@laptop1$ git status
alice@laptop1$ git stash list
\end{minted}
\subsection{Faire une correction de bug}
......@@ -366,36 +332,36 @@ Pour faire faire la correction \textit{Alice} reprend le travail depuis
la version v1.0 de «master». Elle crée alors une nouvelle branche,
«hotfix1», pour y écrire la correction.
\begin{alice}
git checkout v1.0 # attention tête détachée !
git checkout -b hotfix1
\end{alice}
\begin{minted}{console}
alice@laptop1$ git checkout v1.0 # attention tête détachée !
alice@laptop1$ git checkout -b hotfix1
\end{minted}
Elle modifie \texttt{fichier.txt} et crée un commit dans
«hotfix1».
\begin{alice}
mon_editeur_prefere fichier.txt
git add -p
git commit
gitk --all
\end{alice}
\begin{minted}{console}
alice@laptop1$ mon_editeur_prefere fichier.txt
alice@laptop1$ git add -p
alice@laptop1$ git commit
alice@laptop1$ gitk --all
\end{minted}
Elle fusionne ensuite ce commit avec «master» et «develop», en prenant
soin de bien créer un nouveau commit dans les deux cas. Le nouveau
commit de «master» sera tagué \texttt{v1.1} et publié sur
«origin». Elle pourrait avoir à gérer quelques conflits.
\begin{alice}
git checkout master
git merge --no-ff hotfix1
git tag -a v1.1
git push --tags
git push
git checkout develop
git merge --no-ff hotfix1
git push
gitk --all
\end{alice}
\begin{minted}{console}
alice@laptop1$ git checkout master
alice@laptop1$ git merge --no-ff hotfix1
alice@laptop1$ git tag -a v1.1
alice@laptop1$ git push --tags
alice@laptop1$ git push
alice@laptop1$ git checkout develop
alice@laptop1$ git merge --no-ff hotfix1
alice@laptop1$ git push
alice@laptop1$ gitk --all
\end{minted}
\subsection{Sortir de la cachette}
......@@ -405,34 +371,34 @@ lesquels elle travaillait. Elle aura peut-être quelques conflits à
résoudre. Il faudra aussi fusionner la version distante et locale de
«topic2».
\begin{alice}
git checkout topic2
git rebase develop
git pull
git stash list
git stash pop
\end{alice}
\begin{minted}{console}
alice@laptop1$ git checkout topic2
alice@laptop1$ git rebase develop
alice@laptop1$ git pull
alice@laptop1$ git stash list
alice@laptop1$ git stash pop
\end{minted}
Ensuite \textit{Alice} finit ses modifications, enregistre un commit et
fusionne la branche dans «develop» en prenant soin de bien créer un
nouveau commit.
\begin{alice}
mon_editeur_prefere fichier.txt
git add -p
git commit
git checkout develop
git merge --no-ff topic2
git push
gitk --all
\end{alice}
\begin{minted}{console}
alice@laptop1$ mon_editeur_prefere fichier.txt
alice@laptop1$ git add -p
alice@laptop1$ git commit
alice@laptop1$ git checkout develop
alice@laptop1$ git merge --no-ff topic2
alice@laptop1$ git push
alice@laptop1$ gitk --all
\end{minted}
\textit{Alice} remarque que la branche distante de «topic2» est en retard.
Pour pousser l'ensemble des distantes branches en retard
(comme «topic2») \textit{Alice} effectue
\begin{alice}
git push --all
\end{alice}
\begin{minted}{console}
alice@laptop1$ git push --all
\end{minted}
\subsection{Nouvelle version majeure}
......@@ -443,25 +409,25 @@ corrigeant quelques problèmes. Il fusionne ensuite cette branche dans
«master» et «develop» en créant un nouveau commit dans les deux
cas. La nouvelle version du «master» est publiée avec le tag v2.0.
\begin{bob}
git fetch dev
git checkout develop
git pull
git checkout -b release2
mon_editeur_prefere fichier.txt
git add -p
git commit
git checkout master
git pull
git merge --no-ff release2
git tag -a v2.0
git push --tags
git push
git checkout develop
git merge --no-ff release2
git push
gitk --all
\end{bob}
\begin{minted}{console}
bob@laptop2$ git fetch dev
bob@laptop2$ git checkout develop
bob@laptop2$ git pull
bob@laptop2$ git checkout -b release2
bob@laptop2$ mon_editeur_prefere fichier.txt
bob@laptop2$ git add -p
bob@laptop2$ git commit
bob@laptop2$ git checkout master
bob@laptop2$ git pull
bob@laptop2$ git merge --no-ff release2
bob@laptop2$ git tag -a v2.0
bob@laptop2$ git push --tags
bob@laptop2$ git push
bob@laptop2$ git checkout develop
bob@laptop2$ git merge --no-ff release2
bob@laptop2$ git push
bob@laptop2$ gitk --all
\end{minted}
\section{En conclusion}
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment