# leshed Docker
leshed powered by druapl 10 in docker environement (nginx, php:8.3-fpm+drush, mariadb, redis, phpmyadmin, x-debug)

## Install docker
```
sudo pacman -S docker docker-compose docker-machine
```
art the docker service
```
sudo systemctl start docker
```

For all the following, DO NOT run docker or make commande as root or with sudo, use this setup: add your user to the docker user group, re-login, and restart docker.service.

https://wiki.archlinux.org/index.php/Docker#Installation

## Clone this repos

this will clone this repos (main docker environement) and the leshed drupal 10 source code (without sites/default folder nor mysq ddbs)

```
git clone --recursive -o figli https://figureslibres.io/gitea/bachir/docker-leshed.git
```

submodules :
- https://figureslibres.io/gitea/bachir/drupal-leshed

## touch log file
```
touch log/nginx/error.log
touch log/nginx/leshed/error.log
```

### setup /sites/default/settings.php

```
cp -r ressources/drupal/settings.php src/web/sites/default/
cp -r ressources/drupal/settings.local.php src/web/sites/default/
cp -r ressources/drupal/services.yml src/web/sites/default/
```
### get the sites/default/salt.txt file (if you don't have it, you don't)

### get the sites/default/files folder
rsync the files from you know where (if you don't, you don't) to src/sites/default/files/

## Mysql
Copy your-sql-dump.sql files into ```./ressources/leshed.sql```
They will be automaticly imported into the mysql containers dbs (only) on the first docker-compose up

## Hosts and reverse proxy

add to your /etc/hosts :
```
127.0.0.1	dev.leshed.fr
127.0.0.1	dev.phpmyadmin.leshed.fr
```
configure your vhosts to add a reverse proxy that will redirect the dev.materio.com to our container

### nginx

```sh
sudo mkdir /etc/var/log/leshed
```

```nginx
server {
     listen 80;
     server_name dev.leshed.fr;

     access_log off;
     error_log  /var/log/nginx/leshed/error.log error;

     client_max_body_size 100m;

     location / {
         proxy_pass http://127.0.0.1:8980;
         proxy_set_header Host $host;
         proxy_set_header X-Real-IP $remote_addr;
         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
         proxy_set_header X-Forwarded-Proto $scheme;
         proxy_buffer_size          128k;
         proxy_buffers              4 256k;
         proxy_busy_buffers_size    256k;
     }
 }
 server {
     listen 80;
     server_name dev.phpmyadmin.leshed.fr;

     location / {
         proxy_pass http://127.0.0.1:8981;
         proxy_set_header Host $host;
         proxy_set_header X-Real-IP $remote_addr;
         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
         proxy_set_header X-Forwarded-Proto $scheme;
         proxy_buffer_size          128k;
         proxy_buffers              4 256k;
         proxy_busy_buffers_size    256k;
     }
 }
```

### apache
```apache
<Virtualhost *:80>
  ServerName dev.leshed.fr
  ProxyPass / http://127.0.0.1:8980/
  ProxyPassReverse / http://127.0.0.1:8980/
  ProxyRequests Off
  ProxyPreserveHost On
  proxy_buffer_size          128k;
  proxy_buffers              4 256k;
  proxy_busy_buffers_size    256k;
</Virtualhost>
<Virtualhost *:80>
  ServerName dev.phpmyadmin.leshed.fr
  ProxyPass / http://127.0.0.1:8981/
  ProxyPassReverse / http://127.0.0.1:8981/
  ProxyRequests Off
  ProxyPreserveHost On
  proxy_buffer_size          128k;
  proxy_buffers              4 256k;
  proxy_busy_buffers_size    256k;
</Virtualhost>
```

## Docker

For all the following, DO NOT run docker or make commande as root or with sudo, use your regular user but first add your user to the docker user group, re-login, and restart docker.service.

```sh
usermod -aG docker yourusername
# https://wiki.archlinux.org/title/Docker#Installation
restart
```

### docker-compose pull
pull the latest image of services
```sh
make pull
```

### build
only before the first run (may take some time)
/!\ DO NOT use ```docker-compose build```, it will fail (check Makefile for more info)
```sh
make build
```

### run
then each time you want to launch the app
```sh
make up
```
Be aware that a first up, since the db is empty, it will be populated with your files ressources/db_d7.sql and ressources/db_d9.sql. It may take some time depending of your db size.

## Drupal Composer install
Only at first up, finish to install drupal composer dependencies
```sh
make exec_php
composer install
# or juste
make composer_install
```

## Visualize
You can now visit http://dev.leshed.fr on your browser
After the first run

## Mobile : tester et inspecter sur téléphone

En dev (`APP_ENV=development`), le thème charge ses assets depuis le serveur
Vite du laptop (`leshed/vitehmr`, voir `leshed.theme`) — des URLs en
`http://localhost:5173`. Sur le téléphone, «localhost» désigne le téléphone :
il faut un tunnel ADB pour que ces URLs atteignent le Vite du laptop.

### Procédure pas à pas

L'association (étapes 1 à 3) ne se fait qu'une fois — ou si l'étape 4 refuse
de connecter. Ensuite, chaque session de travail commence à l'étape 4.

**1. [Téléphone]** Paramètres → Options pour développeurs → activer
**« Débogage sans fil »**. Ouvrir son écran (l'option activée ne suffit pas :
les ports ne sont lisibles que sur cet écran). Et dans Firefox → Paramètres :
activer **« Remote debugging via USB »** (nécessaire pour l'inspection,
étape 7).

**2. [Téléphone]** Sur cet écran, taper **« Associer l'appareil avec un code
d'appairage »** : une popup affiche une adresse `IP:PORT` et un **code à 6
chiffres**. Laisser la popup ouverte.

**3. [Ordinateur]** Associer (avec le port de la popup de l'étape 2) :

```sh
make mobile_associate ADDR=192.168.1.101:PORT
```

Saisir le code à 6 chiffres quand adb le demande. Répondre « Successfully
paired » → fermer la popup sur le téléphone.

**4. [Téléphone]** Revenir sur l'écran « Débogage sans fil » et lire la ligne
**« Adresse IP et port »** — attention, ce port de *connexion* est différent du
port de pairing de l'étape 2, et il change à chaque réactivation du débogage
sans fil. Il faut le relire à chaque session.

**5. [Ordinateur]** Connecter et poser les tunnels :

```sh
make mobile_inspect ADDR=192.168.1.101:PORT
```

Répondre « OK : tunnels posés ». La cible connecte l'appareil puis pose :
- `adb reverse tcp:5173 tcp:5173` — le `localhost:5173` du mobile pointe vers
  le Vite du laptop. **Sans lui, la page charge sans styles ni JS, sans erreur
  visible** (les requêtes restent en attente).
- `adb forward tcp:9223 localabstract:org.mozilla.firefox/firefox-debugger-socket` —
  le socket de débogage de Firefox Android devient joignable en local sur le
  port 9223. Pas 9222 : ce port est réservé au `--remote-debugging-port` du
  Firefox desktop (WebDriver BiDi), avec qui il entrerait en collision.

**6. [Téléphone]** Recharger la page `dev.leshed.fr` dans Firefox : les styles
apparaissent. Si la page reste nue, voir « Piège connu » ci-dessous.

**7. [Ordinateur]** Pour inspecter, ouvrir `about:debugging#/setup` dans le
Firefox desktop : le téléphone apparaît dans la colonne de gauche →
**This Firefox** → la liste des onglets du téléphone s'affiche → **« Inspect »**
sur l'onglet voulu : une fenêtre DevTools complète, branchée sur la page du
téléphone.

**8. [Téléphone + Ordinateur]** On travaille en parallèle : les éditions SCSS
repartent sur le téléphone par HMR à chaque sauvegarde, sans rechargement. La
mesure scriptée (si l'agent est lancé) interroge la même page par le port 9223.

### Variante USB (plus simple)

Pas de code d'appairage, pas de port à lire : l'« association » USB est
l'autorisation donnée sur le téléphone.

**1. [Téléphone]** Brancher le câble, activer **« Débogage USB »** dans les
Options pour développeurs. À la première connexion, une popup demande
d'autoriser l'ordinateur : cocher **« Toujours autoriser depuis cet
ordinateur »**, valider. (Firefox → Paramètres → **« Remote debugging via
USB »** doit aussi être activé, comme en étape 1 du sans fil.)

**2. [Ordinateur]** Vérifier que l'appareil est vu et autorisé :

```sh
make mobile_associate_usb
```

Si la réponse est « unauthorized », revalider la popup sur le téléphone.

**3. [Ordinateur]** Poser les tunnels (mêmes tunnels que `mobile_inspect`) :

```sh
make mobile_inspect_usb
```

**4. [Téléphone]** Recharger la page `dev.leshed.fr` — puis l'inspection
(`about:debugging`) et le travail en parallèle se déroulent comme aux étapes
6 à 8 du sans fil.

### Piège connu : les tunnels meurent en silence

Après tout changement de transport ADB (passage USB ↔ sans fil, reboot du
téléphone, réactivation du débogage), le reverse/forward existent toujours
côté téléphone mais n'aboutissent plus — symptôme : les assets ne chargent
plus. Relancer la cible qui correspond au transport courant
(`mobile_inspect ADDR=IP:PORT` en sans fil, `mobile_inspect_usb` en USB),
puis recharger la page sur le téléphone.

## Coding
### drush
you can access to drush by loging into the php container
```sh
make exec_php
```
once inside the php container in /var/www/html you can use drush as usual


## Updating code

```sh
git pull figli master
# then update all submodules
git submodule update --recursive --checkout
# if you updated d9 code then run
make maj_config
```

## Updating manualy the mysql db
copy your db backup into the mysql container
```sh
docker cp your-db-file.sql leshed-mysql-1:/root/
```
log into mysql container
```sh
make exec_mysql
```
once inside the mysql container you can use mysql command to drop then create and load the db with your file
```
mysql -uroot -pleshed
> drop database leshed;
> create database leshed;
> exit;
mysql -uroot -pleshed leshed < your-db-file-name.sql
```


## Makefile

DO NOT use directly docker or docker-compose to run this instance

use make instead like ```make up```

```makefile
#!/usr/bin/make

SHELL = /bin/sh

USER_UID := $(shell id -u)
USER_UNAME := $(shell id -un)
USER_GID := $(shell id -g)
USER_GNAME := $(shell id -gn)
DATE_NOW := $(shell date '+%Y-%m-%d_%H%M%S')

export USER_UID
export USER_UNAME
export USER_GID
export USER_GNAME
# export DATE_NOW


pull:
		docker-compose pull

build:
		docker-compose build --build-arg USER_UID=$(USER_UID) --build-arg USER_UNAME=$(USER_UNAME) --build-arg USER_GID=$(USER_GID) --build-arg USER_GNAME=$(USER_GNAME)

buildnc:
		docker-compose build --no-cache --build-arg USER_UID=$(USER_UID) --build-arg USER_UNAME=$(USER_UNAME) --build-arg USER_GID=$(USER_GID) --build-arg USER_GNAME=$(USER_GNAME)

downbuildup: down build up

up:
		docker-compose up -d

ps:
		docker-compose ps

logs:
		docker-compose logs -f

maj_config: crd composer_install updb cim cr pag #dev.phpmyadmin.leshed.fr

crd:
		docker exec leshed-php-1 /bin/bash -c "drush cache-clear drush"

composer_install:
		docker exec leshed-php-1 /bin/bash -c "composer install --no-dev"

updb:
		docker exec leshed-php-1 /bin/bash -c "drush updb -y"

cim:
		docker exec leshed-php-1 /bin/bash -c "drush config-import -y"

# sync_struct:
# 		docker exec leshed-php-1 /bin/bash -c "drush im --choice safe && drush ib --choice full"

cr:
		docker exec leshed-php-1 /bin/bash -c "drush cr"

pag:
		docker exec leshed-php-1 /bin/bash -c "drush pag all canonical_entities:node && drush pag all canonical_entities:taxonomy_term"

restart_nginx:
		docker-compose restart nginx

restart_php:
		docker-compose restart php

down:
		docker-compose down

exec_nginx:
		docker exec -it leshed-nginx-1 bash

exec_php:
		docker exec -it leshed-php-1 bash

exec_mysql:
		docker exec -it leshed-mysql-1 bash

dump_db:
	docker exec leshed-mysql-1 sh -c 'exec mysqldump -uroot -pleshed leshed' > ./ressources/leshed-$(DATE_NOW)-local.sql


```