# Jenkins SCO — Deploy Server

Jenkins centralizado para el despliegue de software en terminales SCO (Self-Checkout) en producción.

## Estructura del repositorio

```
.
├── docker-compose.yml
└── data/
    └── jenkins/
        ├── Dockerfile                  # Imagen Jenkins con plugins
        ├── jenkins.yaml                # Configuración JCasC (nodos, seguridad, jobs)
        ├── deploy/
        │   └── install.sh              # Script desplegado en cada SCO
        └── pipelines/
            └── Jenkinsfile.ralph       # Pipeline del cliente Ralph
```

## Arquitectura

- **Jenkins master**: corre en Docker en un servidor (`172.19.13.204`).
- **Agentes (SCOs)**: cada terminal SCO conecta al master vía JNLP (puerto 50000). El proceso del agente corre como `root`.
- **Storage**: Minio almacena el software de cada cliente en buckets separados (ej: bucket `ralph`).

### Labels de agentes

Formato: `sco <cliente> <tienda>`

| Cliente | Tienda | Agentes |
|---|---|---|
| ralph | yabucoa | sco02–sco07 |
| ralph | san-lorenzo | sco03–sco06 |
| ralph | rio-grande | sco01–sco06 |

## Levantar el servidor

```sh
docker compose up -d --build
```

Jenkins queda disponible en `http://<server-ip>:8080` (admin / admin123).

## Conectar un agente SCO

1. Descargar el agente desde Jenkins:
   ```sh
   curl -sO http://<server-ip>:8080/jnlpJars/agent.jar
   mv agent.jar /opt/jenkins-agent/agent.jar
   ```

2. Obtener el secret del nodo: en Jenkins → *Manage Jenkins → Nodes → (nombre del nodo)*.

3. Crear el servicio systemd en el SCO:
   ```ini
   # /etc/systemd/system/jenkins-agent.service
   [Unit]
   Description=Jenkins Agent
   After=network.target

   [Service]
   User=root
   ExecStart=/usr/bin/java -jar /opt/jenkins-agent/agent.jar \
     -url http://<server-ip>:8080/ \
     -secret <SECRET> \
     -name "<nombre-del-nodo>" \
     -workDir "/opt/jenkins-agent"
   Restart=always
   RestartSec=10

   [Install]
   WantedBy=multi-user.target
   ```

4. Habilitar y arrancar:
   ```sh
   systemctl daemon-reload
   systemctl enable --now jenkins-agent
   ```

## Ejecutar un deploy

1. En Jenkins, abrir el job `deploy-ralph`.
2. Click en **Build with Parameters**.
3. Seleccionar la **tienda** destino en el dropdown (yabucoa / san-lorenzo / rio-grande).
4. El pipeline despliega `install.sh ralph` en paralelo en todos los SCOs online de esa tienda.

## Qué hace `install.sh`

Recibe el nombre del cliente como argumento (`$1`):

1. Genera config de rclone apuntando al Minio local.
2. Sincroniza el bucket `$CUSTOMER` desde Minio hacia `/opt/sco/` en el SCO (excluyendo datos persistentes del backend).
3. Ajusta permisos en `/opt/sco/`.
4. Instala servicios systemd desde `/opt/sco/resources/services/`.
5. Configura autostart del usuario `sco`.
6. Instala crontabs de `root` y `sco`.
7. Instala paquetes Python offline.
8. Carga imágenes Docker.
9. Inicializa carpetas y archivos de base de datos del cpi-server.
10. Genera `engine.properties` para SymmetricDS (solo en primera instalación).

## Agregar un nuevo cliente

1. Agregar los nodos del cliente en `data/jenkins/jenkins.yaml` con el label `sco <cliente> <tienda>`.
2. Crear `data/jenkins/pipelines/Jenkinsfile.<cliente>` con el dropdown de tiendas.
3. Agregar el job en la sección `jobs` de `jenkins.yaml`.
4. Montar el nuevo Jenkinsfile en `docker-compose.yml`.
5. Recrear el contenedor: `docker compose up -d --build`.