Rappels indispensables

Point de départ

// ── 1. Fusion contre rebasage ─────────────────────────────────────────────
// Un commit : identifiant, message, parents.
let compteur = 0;
const commit = (msg, parents) => ({ id: "c" + (++compteur), msg, parents });

function creerDepot() {
  const a = commit("A : socle", []);
  const b = commit("B : lecture config", [a]);
  const c = commit("C : correctif principal", [b]);      // sur main
  const d = commit("D : début fonctionnalité", [b]);     // sur la branche
  const e = commit("E : fin fonctionnalité", [d]);
  return { a, b, c, d, e };
}

function fusionner(depot) {
  // La fusion CONSERVE d et e tels quels, et crée un commit à deux parents.
  const m = commit("M : fusion de la branche", [depot.c, depot.e]);
  return [depot.a, depot.b, depot.c, depot.d, depot.e, m];
}

function rebaser(depot) {
  // ← à écrire : rejouer d et e AU-DESSUS de c. Ce sont de NOUVEAUX commits.
  return [];
}

function afficher(nom, commits) {
  console.log("   " + nom);
  for (const c of commits) {
    const p = c.parents.map((x) => x.id).join(", ") || "—";
    console.log("      " + c.id.padEnd(4) + c.msg.padEnd(28) + "parents : " + p);
  }
}

// ── 2. Effet de la durée de vie des branches ──────────────────────────────
// Modèle simple : chaque jour, chaque contributeur produit une modification.
// Une branche accumule ses modifications jusqu'à son intégration. Le risque
// de conflit croît avec le nombre de modifications faites AILLEURS pendant
// qu'elle vivait.
function simuler({ contributeurs, jours, dureeBranche }) {
  const modifsParJour = contributeurs;
  const integrations = Math.floor(jours / dureeBranche) * contributeurs;
  const tailleLot = dureeBranche;                    // modifications par lot
  const modifsAilleurs = 0;                          // ← à écrire
  const probaConflit = 0;                            // ← à écrire
  return { integrations, tailleLot, modifsAilleurs, probaConflit,
           delaiIntegration: dureeBranche / 2 };
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Écrivez rebaser(). Comparez les identifiants : que constate-t-on, et
//    pourquoi ne rebase-t-on pas une branche partagée ?
// 2. Complétez simuler() : pendant qu'une branche vit d jours, les autres
//    contributeurs produisent (contributeurs − 1) × d modifications.
//    La probabilité de conflit croît avec ce nombre.
// 3. Comparez GitFlow (branches de 15 jours) et trunk-based (0,5 jour) sur
//    six contributeurs et trois mois. Reliez aux indicateurs DORA.

const d = creerDepot();
afficher("après fusion", fusionner(d));

Solution

let compteur = 0;
const commit = (msg, parents) => ({ id: "c" + (++compteur), msg, parents });

function creerDepot() {
  const a = commit("A : socle", []);
  const b = commit("B : lecture config", [a]);
  const c = commit("C : correctif principal", [b]);
  const d = commit("D : début fonctionnalité", [b]);
  const e = commit("E : fin fonctionnalité", [d]);
  return { a, b, c, d, e };
}

function fusionner(depot) {
  const m = commit("M : fusion de la branche", [depot.c, depot.e]);
  return [depot.a, depot.b, depot.c, depot.d, depot.e, m];
}

function rebaser(depot) {
  // On ne DÉPLACE pas d et e : on les REJOUE au-dessus de c, ce qui produit
  // deux commits neufs. Les originaux deviennent inatteignables.
  const dPrime = commit("D' : début fonctionnalité (rejoué)", [depot.c]);
  const ePrime = commit("E' : fin fonctionnalité (rejoué)", [dPrime]);
  return [depot.a, depot.b, depot.c, dPrime, ePrime];
}

function afficher(nom, commits) {
  console.log("   " + nom);
  for (const c of commits) {
    const p = c.parents.map((x) => x.id).join(", ") || "—";
    console.log("      " + c.id.padEnd(5) + c.msg.padEnd(36) + "parents : " + p);
  }
}

console.log("— 1. deux façons d'intégrer le même travail —");
const d1 = creerDepot();
afficher("FUSION : l'histoire est conservée, le graphe se ramifie", fusionner(d1));
console.log("");
const d2 = creerDepot();
const apres = rebaser(d2);
afficher("REBASAGE : une ligne droite, mais des commits NEUFS", apres);
console.log("");
console.log("   Le contenu final est le même. Les identifiants, non : D et E");
console.log("   n'existent plus, remplacés par D' et E'. Tant que la branche est");
console.log("   locale, personne ne s'en aperçoit — c'est l'usage recommandé. Si");
console.log("   un collègue avait déjà récupéré D et E, son dépôt contient une");
console.log("   histoire que le vôtre ne connaît plus, et Git voit deux lignées");
console.log("   divergentes. On réécrit ce qu'on n'a pas partagé, jamais l'inverse.");

console.log("");
console.log("— 2 et 3. l'effet de la durée de vie des branches —");
function simuler({ nom, contributeurs, jours, dureeBranche }) {
  const integrations = Math.round((jours / dureeBranche) * contributeurs);
  const tailleLot = dureeBranche;
  // Pendant qu'une branche vit d jours, les AUTRES produisent leurs propres
  // modifications sur la même base : c'est là que naissent les conflits.
  const modifsAilleurs = (contributeurs - 1) * dureeBranche;
  const probaConflit = Math.min(0.95, 1 - Math.pow(0.97, modifsAilleurs));
  return { nom, integrations, tailleLot, modifsAilleurs, probaConflit,
           delaiIntegration: dureeBranche / 2 };
}

const scenarios = [
  { nom: "GitFlow (branches de 15 j)", contributeurs: 6, jours: 90, dureeBranche: 15 },
  { nom: "intermédiaire (3 j)",        contributeurs: 6, jours: 90, dureeBranche: 3 },
  { nom: "trunk-based (0,5 j)",        contributeurs: 6, jours: 90, dureeBranche: 0.5 },
];
console.log("   stratégie                  | intégrations | modifs/lot | conflit | délai");
for (const s of scenarios) {
  const r = simuler(s);
  console.log("   " + r.nom.padEnd(26) + " | " + String(r.integrations).padStart(12) +
    " | " + String(r.tailleLot).padStart(10) +
    " | " + (r.probaConflit * 100).toFixed(0).padStart(6) + " %" +
    " | " + r.delaiIntegration.toFixed(1).padStart(4) + " j");
}
console.log("   Six contributeurs, trois mois, même volume de travail. Seule change");
console.log("   la durée de vie des branches — et l'on retrouve exactement les");
console.log("   quatre indicateurs du chapitre 1 : la taille des lots gouverne le");
console.log("   délai d'intégration, la fréquence, et le risque.");
console.log("   Une branche de trois semaines EST un lot de trois semaines : un");
console.log("   pipeline qui déploie dix fois par jour n'y change rien, il rend");
console.log("   seulement visible plus tôt un problème constitué depuis longtemps.");

Avant de commencer

• Une machine Linux ou un WSL, avec Git, Node et curl
• L'archive de l'application tickets fournie par l'enseignant

Énoncé

1. Lancer l'application, et échouer — Démarrez l'application fournie, puis tentez de l'atteindre depuis un autre terminal avec curl. Elle ne répond pas. Ne modifiez rien tant que vous n'avez pas suivi les quatre questions du diagnostic. Indice : Le nom se résout-il ? Le port est-il écouté, et sur quelle interface ? La requête arrive-t-elle jusqu'au service ? Que répond-elle ?
2. Identifier l'interface d'écoute — Listez ce qui écoute sur la machine et comparez l'adresse d'écoute à celle que vous interrogez. Corrigez la configuration, sans toucher au code métier. Indice : ss -tlnp montre l'adresse ET le port. Une application liée à 127.0.0.1 est injoignable de l'extérieur.
3. Vérifier les droits — Le script de démarrage fourni n'est pas exécutable. Rendez-le exécutable pour son seul propriétaire, sans donner de droit d'écriture au groupe ni aux autres. Écrivez la valeur octale que vous employez et justifiez-la.
4. Créer le dépôt et sa stratégie — Initialisez un dépôt, poussez-le, protégez la branche principale, et écrivez un fichier CONTRIBUTING.md qui fixe la stratégie de branchement : durée de vie maximale d'une branche, taille maximale d'une demande de fusion, et délai maximal de relecture.
5. Fusion contre rebasage, sur un vrai conflit — À deux, modifiez la même ligne du même fichier sur deux branches. Intégrez la première par fusion, la seconde par rebasage. Comparez les deux historiques obtenus, puis dites laquelle des deux opérations vous vous interdiriez si la branche avait déjà été poussée. Indice : git log --graph --oneline --all rend la différence de forme immédiatement visible.

C'est réussi quand

• ✓ curl obtient une réponse depuis un autre terminal, et vous savez dire quelle question du diagnostic a révélé la cause
• ✓ Le script démarre et ses droits sont justifiés
• ✓ La branche principale refuse un push direct
• ✓ Vous savez énoncer la règle sur le rebasage d'une branche partagée

Correction

dig +short localhost           # 1. le nom se résout
ss -tlnp | grep 3000           # 2. LISTEN 127.0.0.1:3000  <-- la cause
curl -v http://localhost:3000  # 3. la requête n'arrive pas
# rien dans les journaux du service : le problème est en amont

chmod 744 demarrer.sh
# 7 = rwx pour le propriétaire
# 4 = r-- pour le groupe et les autres : lecture seule

## Branches
- Une branche par tâche, DURÉE DE VIE MAXIMALE : 1 jour ouvré.
- Intégration dans main au moins une fois par jour.
- Le travail inachevé est masqué par un drapeau de fonctionnalité,
jamais isolé dans une branche longue.

## Demandes de fusion
- 400 lignes modifiées au maximum ; au-delà, découper.
- Relecture sous 4 h ouvrées.
- Rebasage sur main AVANT la demande, jamais après partage.

git log --graph --oneline --all

*   9f2a1c4 (main) Merge branch 'ajout-filtre'     <-- fusion : le graphe fourche
|\
| * 3d8e7b1 ajout du filtre
* | 7c4b9a2 correctif du tri
|/
* 1a2b3c4 socle

* 5e6f7a8 (main) ajout du filtre (rejoué)          <-- rebasage : ligne droite
* 7c4b9a2 correctif du tri
* 1a2b3c4 socle