Integración continua
Un sistema de Integración Continua compilará proyectos continuamente de forma automática y en todas las plataformas, a medida que vayamos introduciendo cambios en el repositorio.
Ya hemos visto en Portabilidad como mover nuestras aplicaciones entre diferentes plataformas y entornos de desarrollo, permitiéndonos generar ejecutables optimizados para cada CPU y sistema operativo sin tener que modificar ni una línea del código fuente. Ahora vamos a ir un paso más allá automatizando las fases de compilación y test.
Un equipo de trabajo medio puede llegar a modificar el código de un proyecto varias veces al día. En entornos multiplataforma, dichos cambios deben ser compilados y probados en varias máquinas lo antes posible con el fin de subsanar errores o anomalías. Para ello el sistema de Integración Continua (IC) trabajará ininterrumpidamente, en segundo plano y de forma autónoma cada vez que se modifique el contenido del repositorio (Figura 1).

1. Build grid
Lo primero que tenemos que hacer es configurar una red de computadores heterogénea donde coexistan diferentes máquinas con los compiladores apropiados (Figura 2) y que puedan comunicarse entre ellas Habilitar SSH. Los actores principales de esta red son:
- Build Grid: Red formada por todas las máquinas que van a cooperar en tareas de compilación. Pueden estar distribuidas por Internet.
- Build Master: Ordenador dentro de la red que ejecuta la utilidad de Integración Continua, coordina al resto de máquinas, almacena los resultados y notifica errores.
- Build Host/Slave: Máquina destinada a tareas de compilación y test, que será manejada remotamente por el Build Master.
- Build Agent: Configuración que identifica una versión de compilador y CPU. Por ejemplo, el agente
v142_x64
representa a Visual Studio 2019 (VC++) de 64bits. Un agente puede ser ejecutado por cualquier Host que tenga instalado el compilador apropiado. El Build Master se encargará de balancear la carga. - Build Profile: Perfil que indica todos los targets (librerías y/o ejecutables) a generar dentro de una solución y que agentes deben intervenir. El Build Master puede manejar varios perfiles al mismo tiempo.
- Build Config: Indica el nivel de optimización y opciones de depuración de la compilación:
Debug
,Release
,ReleaseWithAssert
. Configuraciones.

2. Línea de comandos
Por muy complejos que puedan llegar a ser los Build Profile el proceso de compilación remota se puede dividir en cuatro pasos:
- Actualizar: La copia de trabajo del host, si está desactualizada.
- CMake: Para generar las soluciones de compilación
.sln
,.xcodeproj
óMakefile
. - Build: Compilar mediante
msbuild
,xcodebuild
omake
en función de la plataforma. - Copiar: Resultados de compilación, errores, warnings, librerías o ejecutables. El Master empaquetará todos los productos y presentará informes.
El Build Master deberá utilizar la versión por línea de comandos de todas las herramientas implicadas y lanzarlas en el host remoto mediante SSH. Repasaremos su sintaxis a continuación.
2.1. SVN desde línea de comandos
1 2 |
svn info --show-item revision svn://192.168.1.2/svn/myrepo -r HEAD 1642 |
1 |
svn checkout --username USER --password PASS svn://192.168.1.2/svn/NAPPGUI/1_0 C:\src -r 1642 |
stdout
.
1 |
svn list svn://192.168.1.2/svn/NAPPGUI/1_0/src/osbs -r 1642 |
stdout
.
1 |
svn cat svn://192.168.1.2/svn/NAPPGUI/1_0/src/osbs/bmem.h -r 1642 |
2.2. CMake desde línea de comandos
1 2 |
cd C:\build cmake -G"Visual Studio 15 2017 Win64" -Tv141 C:\src |
1 |
sudo "/Applications/CMake.app/Contents/bin/cmake-gui" --install |
1 2 |
cd /Users/fran/build cmake -G"Xcode" -DCMAKE_ARCHITECTURE:STRING=x86_64 /Users/fran/src |
Makefile
, para compilar con GCC.
1 2 |
cd /home/fran/build cmake -G"Unix Makefiles" -DCMAKE_BUILD_TYPE:STRING=Debug -DCMAKE_ARCHITECTURE:STRING=x64 -DCMAKE_TOOLKIT=GTK3 /home/fran/src |
En macOS y Linux podemos alternar entre diferentes versiones del compilador, como ya vimos en Múltiples versiones de Xcode y Múltiples versiones de GCC. Esto debe hacerse antes de lanzar cmake.
2.3. Visual Studio desde línea de comandos
Para compilar una solución de Visual Studio desde línea de comandos tendremos que utilizar el comando MSBuild.exe
, incluido en la distribución del entorno de Microsoft.
1 2 |
cd C:\build MSBuild.exe Project.sln /flp1:warningsonly;logfile=warnings.txt /flp2:errorsonly;logfile=errors.txt /p:Configuration=Debug /p:Platform=x64 /maxcpucount:1 |
Este comando redirige a stdout
los mensajes del compilador. Los avisos y errores encontrados en el código los guardará en los archivos warnings.txt
y errors.txt
respectivamente.
2.4. Xcode desde línea de comandos
De igual forma que Visual Studio, Xcode se puede ejecutar desde línea de comandos. La sintaxis es la siguiente:
1 2 |
cd /Users/fran/build xcodebuild -project Project.xcodeproj -alltargets -configuration Debug |
También redirige a stdout
el resultado de la compilación. A diferencia de MSBuild
los avisos y errores los escribe en stderr
, precedidos de las etiquetas warning:
y error:
respectivamente.
2.5. GCC/Make desde línea de comandos
En Linux el proyecto se genera mediante archivos Makefile
, que contienen guiones de compilación basados en GCC. CMake se ha encargado de crear estos Makefile
, así que lo único que hay que hacer es ejecutar el comando make
.
make
desde línea de comandos.
1 2 |
cd /home/fran/build make |
2.6. Copias remotas
De nuevo haremos uso del protocolo SSH, concretamente del comando scp
para realizar la copia remota desde el Host hasta el Master.
1 |
scp fran@192.168.1.24:/build/Debug/core/libcore.a C:/pkg |