Set-OPS-Public/roles/serveur_forgejo/tasks/main.yml

---

# L'URL PUBLIQUE de l'IdP se derive de l'exposition declaree au plan, elle ne se
# fabrique pas : `keycloak.<domaine>` n'est publie nulle part (voir resoudre_idp).
#
# ON NE RESOUT PAS UN FOURNISSEUR QU'ON N'UTILISERA PAS (2026-08-25).
#
# Cette resolution partait INCONDITIONNELLEMENT, y compris quand OIDC est desactive.
# `resoudre_idp` lit les registres du plan (`applications.yml`, `domaines.yml`) et exige
# que l'IdP y declare une exposition. Sur une forge SANS Keycloak — celle du site, qui
# porte le genome et n'a pas d'annuaire — il n'y a ni Keycloak ni plan : le role echouait
# sur `'setops_plan_dir' is undefined`, un message qui ne dit rien de la vraie cause.
#
# `serveur_forgejo_oidc_actif` derive deja de la presence du groupe `serveur_keycloak`.
# Il suffisait de s'en servir ici aussi : la resolution suit l'usage.
- name: Resoudre le fournisseur d'identite (role partage)
  ansible.builtin.include_role:
    name: resoudre_idp
  vars:
    resoudre_idp_realm: "{{ serveur_forgejo_oidc_realm }}"
  when: serveur_forgejo_oidc_actif | bool
- name: Refuser de fermer la connexion locale sur un Forgejo anterieur a la v10
  # `ENABLE_INTERNAL_SIGNIN` a ete ajoute en v10 (suivi amont, issue 7476). Sur une
  # version anterieure il est ignore EN SILENCE : le role croirait avoir ferme la porte
  # alors qu'elle reste ouverte. On refuse plutot que de laisser croire.
  ansible.builtin.assert:
    that:
      - serveur_forgejo_version is version('10.0.0', '>=')
    fail_msg: >-
      serveur_forgejo_connexion_locale=false exige Forgejo >= 10.0.0
      (ici {{ serveur_forgejo_version }}) : le reglage serait ignore sans erreur.
      Mettre a jour, ou assumer la connexion locale en la passant a true.
  when: not (serveur_forgejo_connexion_locale | bool)

- name: Exiger les secrets Forgejo (Vault)
  ansible.builtin.assert:
    that:
      - serveur_forgejo_secret_key | length > 0
      - serveur_forgejo_internal_token | length > 0
      - serveur_forgejo_admin_password | length > 0
    fail_msg: "secret_key, internal_token et admin_password sont requis (Ansible Vault)."

- name: Refuser une base de donnees inconnue
  # Une valeur mal orthographiee ne doit pas retomber en silence sur le defaut : elle
  # ferait deployer PostgreSQL a qui croyait choisir SQLite, et l'ecart se lirait au
  # premier demarrage, pas ici.
  ansible.builtin.assert:
    that:
      - serveur_forgejo_bd in ['postgres', 'sqlite']
    fail_msg: >-
      serveur_forgejo_bd={{ serveur_forgejo_bd }} : valeurs acceptees `postgres` ou
      `sqlite`.

- name: Resoudre la base de donnees depuis le registre (role partage)
  ansible.builtin.include_role:
    name: resoudre_base
  vars:
    resoudre_base_groupe: "{{ serveur_forgejo_groupe }}"
  when: serveur_forgejo_bd == 'postgres'

- name: Adopter les facts de base pour Forgejo
  ansible.builtin.set_fact:
    serveur_forgejo_entree: "{{ resoudre_base_entree }}"
    serveur_forgejo_db_password: "{{ resoudre_base_db_password }}"
    serveur_forgejo_db_host: "{{ resoudre_base_db_host }}"
    serveur_forgejo_db_port: "{{ resoudre_base_db_port }}"
  no_log: true
  when: serveur_forgejo_bd == 'postgres'

- name: Creer l'utilisateur systeme git
  ansible.builtin.user:
    name: "{{ serveur_forgejo_utilisateur }}"
    system: true
    shell: /bin/bash
    home: "/home/{{ serveur_forgejo_utilisateur }}"
    create_home: true
    comment: "Git Version Control"

# Le chemin de destination PORTE la version : `forgejo-10.0.0` ne peut pas designer un
# autre contenu demain. Le binaire est donc immuable une fois pose, et le retelecharger
# n'a aucun sens — or `get_url` sans garde recontacte le serveur distant a CHAQUE
# deploiement, pour 106 Mo deja presents.
#
# Constate le 2026-08-09 pendant le passage d'idempotence : « Connection failure: The
# read operation timed out ». Un deploiement de flotte echouait parce qu'un serveur tiers
# etait lent — sur une plateforme qui se veut souveraine, c'est une dependance de trop
# sur le chemin critique.
- name: Le binaire de cette version est-il deja pose ?
  ansible.builtin.stat:
    path: "/usr/local/bin/forgejo-{{ serveur_forgejo_version }}"
  register: serveur_forgejo_binaire_present

# Le controleur telecharge, puis pousse par SSH — la cible ne tire jamais d'Internet.
# Motif explique en detail dans `roles/serveur_nextcloud/tasks/installer.yml`. C'est
# precisement ce binaire qui a fait tomber un deploiement de flotte le 2026-08-09, sur un
# « read operation timed out » venu d'un serveur tiers.
- name: Cache d artefacts du contrôleur
  ansible.builtin.file:
    path: "{{ serveur_forgejo_cache_local }}"
    state: directory
    mode: "0700"
  delegate_to: localhost
  become: false
  when: not serveur_forgejo_binaire_present.stat.exists

- name: L artefact est-il déjà dans le cache du contrôleur ?
  ansible.builtin.stat:
    path: "{{ serveur_forgejo_cache_local }}/forgejo-{{ serveur_forgejo_version }}"
  register: serveur_forgejo_cache_present
  delegate_to: localhost
  become: false
  when: not serveur_forgejo_binaire_present.stat.exists

# Un serveur tiers intermittent ne doit pas arreter un deploiement de quarante minutes
# (mesure du 2026-08-23 : la meme URL pend, puis rend 200 en 0,48 s au second essai).
# Defaut de `get_url` : 10 s et aucune reprise.
- name: Télécharger le binaire Forgejo dans le cache du contrôleur (une seule fois)
  ansible.builtin.get_url:
    url: "{{ serveur_forgejo_url }}"
    dest: "{{ serveur_forgejo_cache_local }}/forgejo-{{ serveur_forgejo_version }}"
    mode: "0644"
    timeout: 30
  delegate_to: localhost
  become: false
  when:
    - not serveur_forgejo_binaire_present.stat.exists
    - not (serveur_forgejo_cache_present.stat.exists | default(false))
  register: serveur_forgejo_bin
  retries: 5
  delay: 6
  until: serveur_forgejo_bin is succeeded

# VERIFIER LA SIGNATURE AVANT DE POSER UN BINAIRE EXECUTABLE SUR UN HOTE.
#
# C'est un binaire, pas une archive de donnees : ce qu'on depose ici s'execute en tant que
# service. La verification tourne sur le CONTROLEUR, contre la cle versionnee du depot et
# l'empreinte PRIMAIRE epinglee — voir `defaults/main.yml` pour la raison de la primaire.

# Un serveur tiers intermittent ne doit pas arreter un deploiement de quarante minutes
# (mesure du 2026-08-23 : la meme URL pend, puis rend 200 en 0,48 s au second essai).
# Defaut de `get_url` : 10 s et aucune reprise.
- name: Récupérer la signature détachée du binaire
  ansible.builtin.get_url:
    url: "{{ serveur_forgejo_signature_url }}"
    dest: "{{ serveur_forgejo_cache_local }}/forgejo-{{ serveur_forgejo_version }}.asc"
    mode: "0644"
    timeout: 30
    force: true
  delegate_to: localhost
  become: false
  when: not serveur_forgejo_binaire_present.stat.exists
  register: serveur_forgejo_sig
  retries: 5
  delay: 6
  until: serveur_forgejo_sig is succeeded

- name: Vérifier la signature du binaire contre l empreinte épinglée
  ansible.builtin.command:
    argv:
      - python3
      - "{{ role_path }}/../../scripts/verifier_signature.py"
      - --artefact
      - "{{ serveur_forgejo_cache_local }}/forgejo-{{ serveur_forgejo_version }}"
      - --signature
      - "{{ serveur_forgejo_cache_local }}/forgejo-{{ serveur_forgejo_version }}.asc"
      - --cle
      - "{{ role_path }}/files/forgejo-release.asc"
      - --empreinte
      - "{{ serveur_forgejo_signature_empreinte }}"
  delegate_to: localhost
  become: false
  changed_when: false
  when: not serveur_forgejo_binaire_present.stat.exists

- name: Déposer le binaire Forgejo sur l hôte depuis le cache
  ansible.builtin.copy:
    src: "{{ serveur_forgejo_cache_local }}/forgejo-{{ serveur_forgejo_version }}"
    dest: "/usr/local/bin/forgejo-{{ serveur_forgejo_version }}"
    owner: root
    group: root
    mode: "0755"
  when: not serveur_forgejo_binaire_present.stat.exists

- name: Activer la version courante du binaire
  ansible.builtin.file:
    src: "/usr/local/bin/forgejo-{{ serveur_forgejo_version }}"
    dest: "{{ serveur_forgejo_binaire }}"
    state: link
  notify: Redemarrer forgejo

- name: Creer les repertoires de donnees
  ansible.builtin.file:
    path: "{{ serveur_forgejo_data }}/{{ item }}"
    state: directory
    owner: "{{ serveur_forgejo_utilisateur }}"
    group: "{{ serveur_forgejo_utilisateur }}"
    mode: "0750"
  loop:
    - ""
    - custom
    - data
    - log

- name: Creer le repertoire de configuration
  ansible.builtin.file:
    path: "{{ serveur_forgejo_config_dir }}"
    state: directory
    owner: root
    group: "{{ serveur_forgejo_utilisateur }}"
    mode: "0770"

# JWT_SECRET appartient au SERVICE, pas au depot : Forgejo le genere au premier
# demarrage et le persiste dans `app.ini`. Le gabarit ne le portait pas — donc chaque
# rendu l'EFFACAIT, Forgejo en generait un nouveau au redemarrage, et le passage suivant
# recommencait. Autrement dit : chaque deploiement faisait tourner le secret JWT de la
# forge, invalidant les jetons qu'elle avait emis. Trouve par le passage d'idempotence du
# 2026-08-09 — seule ligne differente entre deux rendus.
#
# On le RELIT donc avant de rendre, et on le repose tel quel. Le depot cesse de disputer
# au service une valeur qui lui appartient.
- name: Relire le secret JWT genere par Forgejo (lui appartient)
  ansible.builtin.slurp:
    src: "{{ serveur_forgejo_config }}"
  register: serveur_forgejo_app_ini
  failed_when: false
  no_log: true

- name: Retenir le secret JWT (vide au premier deploiement)
  ansible.builtin.set_fact:
    # Sans groupe de capture : on selectionne la ligne, puis on retire le prefixe. La
    # forme avec `regex_search(..., '\\1', multiline=True)` fonctionnait pourtant en
    # isolation — mais elle echouait sur l'hote, et `no_log` (indispensable ici, c'est un
    # secret) empechait de voir pourquoi. Une expression qu'on ne peut pas diagnostiquer
    # en place doit ceder a une expression plus simple.
    serveur_forgejo_jwt_secret: >-
      {{ (serveur_forgejo_app_ini.content | default('') | b64decode).splitlines()
         | select('match', '^JWT_SECRET *=')
         | map('regex_replace', '^JWT_SECRET *= *', '')
         | first | default('', true) | trim }}
  no_log: true

- name: Deployer app.ini
  ansible.builtin.template:
    src: app.ini.j2
    dest: "{{ serveur_forgejo_config }}"
    owner: "{{ serveur_forgejo_utilisateur }}"   # Forgejo persiste des secrets générés (oauth2 JWT) → doit pouvoir écrire
    group: "{{ serveur_forgejo_utilisateur }}"
    # 0600, et non 0640 : Forgejo REECRIT ce fichier lui-meme (il y persiste des secrets
    # generes) et le repose systematiquement en 0600. Le role remettait 0640 a chaque
    # passage, Forgejo le ramenait a 0600 — deux proprietaires pour un fichier, en
    # desaccord, et un `changed` perpetuel qui redemarrait le service pour rien.
    # Trouve par le passage d'idempotence du 2026-08-09 : contenu identique, diff VIDE,
    # seul le mode differait — c'est ce qui rendait la cause invisible.
    #
    # Le desaccord n'avait aucun effet utile : le groupe est `git`, c'est-a-dire le
    # service lui-meme. On s'aligne sur le plus strict, qui est aussi le sien.
    mode: "0600"
  no_log: true
  notify: Redemarrer forgejo

- name: Deployer l'identite visuelle (logo, favicon, accent aurore, accueil)
  ansible.builtin.copy:
    src: custom/
    dest: "{{ serveur_forgejo_data }}/custom/"
    owner: "{{ serveur_forgejo_utilisateur }}"
    group: "{{ serveur_forgejo_utilisateur }}"
    mode: "0644"
    directory_mode: "0755"
  when: serveur_forgejo_branding | bool
  notify: Redemarrer forgejo

- name: Deployer l'unite systemd forgejo
  ansible.builtin.template:
    src: forgejo.service.j2
    dest: /etc/systemd/system/forgejo.service
    owner: root
    group: root
    mode: "0644"
  notify: Redemarrer forgejo

- name: Activer et demarrer Forgejo
  when: not ansible_check_mode
  ansible.builtin.systemd:
    name: "{{ serveur_forgejo_service }}"
    enabled: true
    state: started
    daemon_reload: true

- name: Appliquer les redemarrages Forgejo (config a jour) avant admin/OAuth2
  ansible.builtin.meta: flush_handlers

- name: Attendre que Forgejo reponde (migrations terminees)
  ansible.builtin.wait_for:
    host: 127.0.0.1
    port: "{{ serveur_forgejo_http_port }}"
    timeout: 120
  when: not ansible_check_mode

- name: Creer le compte administrateur (une fois)
  # `--must-change-password=false` : SANS LUI, LE COMPTE EST INUTILISABLE (2026-08-23,
  # premiere forge de patient 0). Forgejo exige par defaut un changement de mot de passe
  # au premier acces, et refuse TOUTE requete d'API tant qu'il n'a pas eu lieu :
  # « You must change your password ». Or ce role desactive la connexion locale
  # (`serveur_forgejo_connexion_locale: false`, SSO d'abord) — il n'existait donc aucun
  # chemin pour effectuer ce changement. Le compte de secours ne secourait rien.
  #
  # Le mot de passe vient de la voute et tourne par empreinte (voir plus bas) : exiger un
  # changement manuel en plus ferait diverger la voute de la realite, ce que ce role
  # s'emploie justement a empecher.
  ansible.builtin.shell:
    cmd: >-
      {{ serveur_forgejo_binaire }} admin user create
      --admin --username {{ serveur_forgejo_admin_user }}
      --email {{ serveur_forgejo_admin_email }}
      --password '{{ serveur_forgejo_admin_password }}'
      --must-change-password=false
      --config {{ serveur_forgejo_config }}
      && touch {{ serveur_forgejo_data }}/.admin-created
    creates: "{{ serveur_forgejo_data }}/.admin-created"
  become: true
  become_user: "{{ serveur_forgejo_utilisateur }}"
  environment:
    GITEA_WORK_DIR: "{{ serveur_forgejo_data }}"
  no_log: true

# ON VERIFIE L'ETAT, ON NE FAIT PAS CONFIANCE AU DRAPEAU (2026-08-25).
#
# La creation passe deja `--must-change-password=false` — corrige le 2026-08-23, sur la
# premiere forge de patient 0. **Forgejo 16 l'a ignore** : le compte de la forge du SITE
# est ne avec le drapeau POSE malgre l'option.
#
# La panne qui en resulte n'accuse rien de juste : toute requete d'API rend **403**, pas
# 401. Le jeton est valide, l'identite reconnue, la requete rejetee quand meme — on
# cherche un scope, un droit, une politique, et la cause est un drapeau sur le compte.
#
# D'ou cette tache : elle ne demande pas a la creation de bien se comporter, elle CONSTATE
# l'etat voulu et le retablit. Idempotente, et sans effet quand la creation a tenu parole.
- name: Le compte d'administration ne doit exiger aucun changement de mot de passe
  ansible.builtin.command:
    cmd: >-
      {{ serveur_forgejo_binaire }} admin user must-change-password --unset
      {{ serveur_forgejo_admin_user }}
      --config {{ serveur_forgejo_config }}
  become: true
  become_user: "{{ serveur_forgejo_utilisateur }}"
  environment:
    FORGEJO_WORK_DIR: "{{ serveur_forgejo_data }}"
  register: forgejo_mcp
  changed_when: "'Updated 1 users' in (forgejo_mcp.stdout | default(''))"
  failed_when:
    - forgejo_mcp.rc != 0
    - "'not found' not in (forgejo_mcp.stderr | default(''))"

- name: Configurer la source OAuth2 SSO (Keycloak, idempotent)
  ansible.builtin.shell:
    executable: /bin/bash
    cmd: |
      set -euo pipefail
      FJ="{{ serveur_forgejo_binaire }} --config {{ serveur_forgejo_config }}"
      # Les reglages de GROUPE sont RECONCILIES, pas seulement poses a la creation :
      # `add-oauth` une fois puis plus rien laissait un cablage perime vivre
      # indefiniment — c'est ce qui est arrive a la federation LDAP de Keycloak, qui
      # a pointe un hote inexistant pendant des semaines (2026-08-07).
      OPTS_GROUPE=""
      {% if serveur_forgejo_oidc_groupe_admin | length > 0 %}
      OPTS_GROUPE="--group-claim-name {{ serveur_forgejo_oidc_groupe_claim }} --admin-group {{ serveur_forgejo_oidc_groupe_admin }}"
      {% endif %}
      ID=$($FJ admin auth list 2>/dev/null \
           | awk -v n="{{ serveur_forgejo_oidc_nom }}" '$2 == n {print $1}' | head -1)
      if [ -z "$ID" ]; then
        $FJ admin auth add-oauth \
          --name "{{ serveur_forgejo_oidc_nom }}" \
          --provider openidConnect \
          --key "{{ serveur_forgejo_oidc_client_id }}" \
          --secret "$OIDC_SECRET" \
          --auto-discover-url "{{ serveur_forgejo_oidc_discovery }}" \
          $OPTS_GROUPE >/dev/null
        echo SETOPS_CHANGED
      else
        # `update-oauth` est idempotent cote Forgejo : il reecrit les memes valeurs
        # sans effet de bord. On ne peut pas comparer avant/apres (la CLI n'expose
        # pas le detail d'une source), donc on ne signale PAS `changed`.
        # `--secret` fait partie de la reconciliation : sans lui, faire tourner
        # `vault_forgejo_oidc` laissait Forgejo sur l'ancienne valeur.
        $FJ admin auth update-oauth --id "$ID" \
          --auto-discover-url "{{ serveur_forgejo_oidc_discovery }}" \
          --secret "$OIDC_SECRET" \
          $OPTS_GROUPE >/dev/null
        echo SETOPS_OK
      fi
  environment:
    OIDC_SECRET: "{{ serveur_forgejo_oidc_client_secret }}"
    GITEA_WORK_DIR: "{{ serveur_forgejo_data }}"
  become: true
  become_user: "{{ serveur_forgejo_utilisateur }}"
  register: serveur_forgejo_oauth
  changed_when: "'SETOPS_CHANGED' in serveur_forgejo_oauth.stdout"
  no_log: true
  when:
    - serveur_forgejo_oidc_actif | bool
    - not ansible_check_mode

# --- ROTATION DU COMPTE DE SECOURS -------------------------------------------
# `admin user create` porte `creates: .admin-created` : il ne tourne qu'UNE fois.
# Changer la voute ne changeait donc rien, et la voute se mettait a mentir. Meme
# raisonnement que pour Grafana — idempotence par EMPREINTE du secret applique.
- name: Empreinte du mot de passe admin en place
  ansible.builtin.slurp:
    src: "{{ serveur_forgejo_marqueur_admin }}"
  register: serveur_forgejo_marque
  failed_when: false
  changed_when: false
  no_log: true

- name: Appliquer le mot de passe du compte de secours (rotation)
  ansible.builtin.command:
    argv:
      - "{{ serveur_forgejo_binaire }}"
      - "--config"
      - "{{ serveur_forgejo_config }}"
      - admin
      - user
      - change-password
      - "--username"
      - "{{ serveur_forgejo_admin_user }}"
      - "--password"
      - "{{ serveur_forgejo_admin_password }}"
  environment:
    GITEA_WORK_DIR: "{{ serveur_forgejo_data }}"
  become: true
  become_user: "{{ serveur_forgejo_utilisateur }}"
  changed_when: true
  no_log: true
  when: >-
    (serveur_forgejo_marque.content | default('') | b64decode | trim)
    != (serveur_forgejo_admin_password | hash('sha256'))

- name: Retenir l'empreinte appliquee
  ansible.builtin.copy:
    content: "{{ serveur_forgejo_admin_password | hash('sha256') }}\n"
    dest: "{{ serveur_forgejo_marqueur_admin }}"
    owner: root
    group: root
    mode: "0600"
  no_log: true