Xmake es una herramienta de construcción multiplataforma ligera basada en Lua.
Es muy liviano y no tiene dependencias porque tiene un tiempo de ejecución Lua incorporado.
Utiliza xmake.lua para mantener la construcción del proyecto. En comparación con makefile/CMakeLists.txt, la sintaxis de configuración es más concisa e intuitiva, y es muy amigable para los novatos. Puede comenzar rápidamente en poco tiempo, lo que permite a los usuarios concentrarse más. sobre el desarrollo real del proyecto.
Podemos usarlo para compilar proyectos directamente como Make/Ninja, o generar archivos de proyecto como CMake/Meson.Además, tiene un sistema de gestión de paquetes incorporado para ayudar a los usuarios a resolver el uso integrado de bibliotecas dependientes de C/C++.
En la actualidad, Xmake se usa principalmente para la construcción de proyectos C/C++, pero también admite la construcción de otros lenguajes nativos, que pueden realizar una compilación mixta con C/C++, y la velocidad de compilación también es muy rápida, que puede ser igual a Ninja.
Xmake = Build backend + Project Generator + Package Manager + [Remote|Distributed] Build + Cache
Aunque no es muy preciso, aún podemos entender Xmake de la siguiente manera:
Xmake ~= Make/Ninja + CMake/Meson + Vcpkg/Conan + distcc + ccache/sccache
Introducción de nuevas características
En esta versión, hemos agregado un montón de nuevas características de gran peso:
- Soporte de compilación distribuida
- Caché de compilación local incorporado
- Soporte de caché de compilación remota
Con estas funciones, podemos compilar grandes proyectos de C/C++ mucho más rápido. Además, son completamente multiplataforma, admiten no solo gcc/clang sino también msvc, y no hay dependencia de terceros excepto el compilador, que es muy conveniente de usar.
Por lo tanto, usar Xmake es equivalente a usarlo al mismo tiempo . distcc/ccache/sccache
En comparación con estas herramientas de terceros, Xmake es totalmente compatible con Windows y msvc, lo que elimina las diferencias de plataforma, las llamadas a procesos independientes y la sobrecarga de procesos de daemon adicionales.
Además de estas características, la nueva versión de Xmake también agrega soporte de compilación para proyectos Keil/c51, así como soporte para los compiladores nvc/nvc++/nvfortran en la cadena de herramientas nvidia-hpc-sdk.
La compilación remota admite la autenticación de usuarios
En la última versión, inicialmente admitíamos la compilación remota, pero no brindamos soporte de autenticación de usuario, lo que traería algunos problemas de seguridad. Por lo tanto, en esta versión, agregamos soporte de autenticación de usuario.
En la actualidad, Xmake proporciona principalmente los siguientes mecanismos de autenticación. Además, también es eficaz para la compilación distribuida y el almacenamiento en caché remoto.
- Autenticación de tokens
- Autenticación de contraseña
- Verificación de host de confianza
Autenticación de tokens
Este también es el método predeterminado recomendado, que es más seguro, más conveniente para configurar y conectarse, y no necesita ingresar una contraseña cada vez que se conecta.
Cuando ejecutamos el comando, se generará por defecto un archivo de configuración de servidor y cliente, y automáticamente se generará un token por defecto, por lo que la conexión local directa no requiere ninguna configuración. xmake service
Configuración de autenticación del servidor
El servidor se puede configurar con múltiples tokens para autorizar conexiones a diferentes hosts de usuarios y, por supuesto, puede compartir un token.
$ cat ~/.xmake/service/server.conf
{
known_hosts = { },
logfile = "/Users/ruki/.xmake/service/server/logs.txt",
remote_build = {
listen = "0.0.0.0:9691",
workdir = "/Users/ruki/.xmake/service/server/remote_build"
},
tokens = {
"e438d816c95958667747c318f1532c0f"
}
}
Configuración de autenticación de cliente
El cliente solo necesita agregar el token en el servidor a la configuración del cliente correspondiente.
$ cat ~/.xmake/service/client.conf
{
remote_build = {
connect = "127.0.0.1:9691",
token = "e438d816c95958667747c318f1532c0f"
}
}
Generar nuevo token manualmente
También podemos ejecutar el siguiente comando para generar manualmente un nuevo token y agregarlo nosotros mismos a la configuración del servidor.
$ xmake service --gen-token
New token a7b9fc2d3bfca1472aabc38bb5f5d612 is generated!
Autenticación de contraseña
También proporcionamos un modo de autorización de autenticación de contraseña. En comparación con la autenticación de token, requiere que los usuarios ingresen una contraseña cada vez que se conectan, y solo se puede conectar después de pasar la verificación.
Configuración de autenticación del servidor
Para la autenticación de contraseña, no necesitamos configurar manualmente el token, simplemente ejecute el siguiente comando para agregar un usuario.Durante el proceso de adición, se le pedirá al usuario que ingrese una contraseña.
$ xmake service --add-user=ruki
Please input user ruki password:
123456
Add user ruki ok!
Luego, xmake generará un nuevo token a través del nombre de usuario y la contraseña y lo agregará a la lista de tokens configurada por el servidor.
$ cat ~/.xmake/service/server.conf
{
known_hosts = { },
logfile = "/Users/ruki/.xmake/service/server/logs.txt",
remote_build = {
listen = "0.0.0.0:9691",
workdir = "/Users/ruki/.xmake/service/server/remote_build"
},
tokens = {
"e438d816c95958667747c318f1532c0f",
"7889e25402413e93fd37395a636bf942"
}
}
Por supuesto, también podemos eliminar el usuario y la contraseña especificados.
$xmake service --rm-user=ruki
Please input user ruki password:
123456
Remove user ruki ok!
Configuración de autenticación de cliente
Para el cliente, ya no necesitamos configurar el token del servidor, solo necesitamos agregar el nombre de usuario que debe conectarse en la configuración de conexión para habilitar la autenticación de contraseña. El formato es:user@address:port
$ cat ~/.xmake/service/client.conf
{
remote_build = {
connect = "[email protected]:9691"
}
}
!> Si se elimina el nombre de usuario y no se configura el token, es modo anónimo, si el servidor no se configura con el token, la autenticación se deshabilita por completo y la conexión se realiza directamente.
Verificación de host de confianza
Además, para mejorar aún más la seguridad, también proporcionamos verificación de host confiable del lado del servidor.Si la dirección IP del host del cliente que se puede conectar está configurada en la lista de hosts conocidos de la configuración del servidor, entonces solo estos hosts pueden conectarse con éxito. a este host La conexión del servidor y otros hosts a él se indicará como no confiable y rechazará la conexión, incluso si la autenticación del token y la contraseña son correctas.
$ cat ~/.xmake/service/server.conf
{
logfile = "/Users/ruki/.xmake/service/logs.txt",
server = {
tokens = {
"4b928c7563a0cba10ff4c3f5ca0c8e24"
},
known_hosts = { "127.0.0.1", "xx.xx.xx.xx"}
}
}
conectarse a un servidor remoto
A continuación, solo necesitamos ingresar al directorio raíz del proyecto que debe compilarse de forma remota, ejecutar el comando y conectarnos. xmake service --connect
Si es el modo de autenticación de token, no se requiere ingresar una contraseña adicional y la conexión se conecta directamente.
$ xmake create test
$ cd test
$ xmake service --connect
<remote_build_client>: connect 192.168.56.110:9091 ..
<remote_build_client>: connected!
<remote_build_client>: sync files in 192.168.56.110:9091 ..
Scanning files ..
Comparing 3 files ..
[+]: src/main.cpp
[+]: .gitignore
[+]: xmake.lua
3 files has been changed!
Archiving files ..
Uploading files with 1372 bytes ..
<remote_build_client>: sync files ok!
Si se trata de autenticación de contraseña, se le pedirá al usuario que ingrese la contraseña para continuar la conexión.
$ xmake service --connect
Please input user root password:
000000
<remote_build_client>: connect 127.0.0.1:9691 ..
<remote_build_client>: connected!
<remote_build_client>: sync files in 127.0.0.1:9691 ..
Scanning files ..
Comparing 3 files ..
[+]: xmake.lua
[+]: .gitignore
[+]: src/main.cpp
3 files has been changed!
Archiving files ..
Uploading files with 1591 bytes ..
<remote_build_client>: sync files ok!
Si la contraseña es incorrecta, se mostrará un mensaje de error.
$ xmake service --connect
Please input user root password:
123
<remote_build_client>: connect 127.0.0.1:9691 ..
<remote_build_client>: connect 127.0.0.1:9691 failed, user and password are incorrect!
Soporte de compilación distribuida
Xmake proporciona un servicio de compilación distribuido incorporado, por lo general puede cooperar con la caché de compilación local y la caché de compilación remota para lograr una aceleración de compilación óptima.
Además, es totalmente compatible con varias plataformas, no solo admitimos gcc/clang, sino también Windows y msvc.
Para la compilación cruzada, siempre que la cadena de herramientas cruzada lo admita, no necesitamos el entorno del sistema del servidor Incluso si los recursos del servidor de linux, macOS y Windows se mezclan, la compilación distribuida se puede realizar bien.
iniciar el servicio
Podemos especificar un parámetro para habilitar el servicio de compilación distribuida, por supuesto, si no se especifica este parámetro, xmake habilitará todos los servicios configurados en el servidor por defecto. --distcc
$ xmake service --distcc
<distcc_build_server>: listening 0.0.0.0:9093 ..
También podemos iniciar el servicio y hacer eco de la información de registro detallada.
$ xmake service --distcc -vD
<distcc_build_server>: listening 0.0.0.0:9093 ..
Inicie el servicio en modo Daemon
$ xmake service --distcc --start
$ xmake service --distcc --restart
$ xmake service --distcc --stop
Configurar el servidor
Primero, ejecutamos el comando, generará automáticamente un archivo de configuración predeterminado, almacenará en . xmake service server.conf ~/.xmake/service/server.conf
$ xmake service
generating the config file to /Users/ruki/.xmake/service/server.conf ..
an token(590234653af52e91b9e438ed860f1a2b) is generated, we can use this token to connect service.
generating the config file to /Users/ruki/.xmake/service/client.conf ..
<distcc_build_server>: listening 0.0.0.0:9693 ..
Luego, lo editamos, arreglando el puerto de escucha del servidor (opcional).
$ cat ~/.xmake/service/server.conf
{
distcc_build = {
listen = "0.0.0.0:9693",
workdir = "/Users/ruki/.xmake/service/server/distcc_build"
},
known_hosts = { },
logfile = "/Users/ruki/.xmake/service/server/logs.txt",
tokens = {
"590234653af52e91b9e438ed860f1a2b"
}
}
Configurar el cliente
El archivo de configuración del cliente está ahí , podemos configurar la dirección del servidor a la que el cliente necesita conectarse. ~/.xmake/service/client.conf
Podemos configurar varias direcciones de servidor y tokens correspondientes en la lista de hosts.
!> Compilación distribuida, se recomienda usar el modo de autenticación de token, debido al modo de contraseña, cada servidor necesita ingresar la contraseña una vez al conectarse, lo cual es muy engorroso.
$cat ~/.xmake/service/client.conf
{
distcc_build = {
hosts = {
{
connect = "127.0.0.1:9693",
token = "590234653af52e91b9e438ed860f1a2b"
}
}
}
}
conectarse al servidor
Después de configurar la autenticación y la dirección del servidor, puede ingresar el siguiente comando para conectar el proyecto actual al servidor configurado.
Necesitamos ingresar, al conectar , para especificar que solo el servicio distribuido está conectado. --distcc
$ cd projectdir
$ xmake service --connect --distcc
<client>: connect 127.0.0.1:9693 ..
<client>: 127.0.0.1:9693 connected!
También podemos conectarnos a múltiples servicios al mismo tiempo, como la compilación distribuida y los servicios de caché de compilación remota.
$ xmake service --connect --distcc --ccache
!> Si no hay ningún parámetro, la conexión por defecto es el servicio de compilación remota.
Proyecto de compilación distribuida
Después de conectarnos al servidor, podemos realizar una compilación distribuida como una compilación local normal, por ejemplo:
$ xmake
...
[ 93%]: ccache compiling.release src/demo/network/unix_echo_client.c ----> local job
[ 93%]: ccache compiling.release src/demo/network/ipv6.c
[ 93%]: ccache compiling.release src/demo/network/ping.c
[ 93%]: distcc compiling.release src/demo/network/unix_echo_server.c. ----> distcc job
[ 93%]: distcc compiling.release src/demo/network/http.c
[ 93%]: distcc compiling.release src/demo/network/unixaddr.c
[ 93%]: distcc compiling.release src/demo/network/ipv4.c
[ 94%]: distcc compiling.release src/demo/network/ipaddr.c
[ 94%]: distcc compiling.release src/demo/math/fixed.c
[ 94%]: distcc compiling.release src/demo/libm/float.c
[ 95%]: ccache compiling.release src/demo/libm/double.c
[ 95%]: ccache compiling.release src/demo/other/test.cpp
[ 98%]: archiving.release libtbox.a
[ 99%]: linking.release demo
[100%]: build ok!
Entre ellos, las palabras con distcc son tareas de compilación remota, y las otras son tareas de compilación local.Por defecto, xmake también habilita el almacenamiento en caché de compilación local para almacenar en caché los resultados de compilación distribuida para evitar solicitudes frecuentes al servidor.
Además, también podemos abrir el caché de compilación remota y compartir el caché de compilación con otros para acelerar aún más la compilación del desarrollo colaborativo de varias personas.
Desconectar
$ xmake service --disconnect --distcc
Especificar el número de tareas de compilación paralelas
Presentemos brevemente la cantidad de tareas paralelas actualmente calculadas de forma predeterminada en función de la cantidad de núcleos de CPU del host:
local default_njob = math.ceil(ncpu * 3 / 2)
Por lo tanto, si la compilación distribuida no está habilitada, el número máximo predeterminado de tareas de compilación en paralelo es este default_njob.
Si la compilación distribuida está habilitada, el número predeterminado de tareas de compilación en paralelo es:
local maxjobs = default_njob + server_count * server_default_njob
Modificar el número de tareas paralelas locales
Podemos especificar la cantidad de tareas paralelas locales solo pasándola , pero no afectará la cantidad de tareas paralelas en el lado del servidor. -jN
$ xmake -jN
Modificar el número de tareas paralelas en el servidor
Si desea modificar la cantidad de tareas paralelas en el servidor, debe modificar el archivo de configuración del cliente.
$cat ~/.xmake/service/client.conf
{
distcc_build = {
hosts = {
{
connect = "127.0.0.1:9693",
token = "590234653af52e91b9e438ed860f1a2b",
njob = 8 <------- modify here
},
{
connect = "192.168.01:9693",
token = "590234653af52e91b9e438ed860f1a2b",
njob = 4
}
}
}
}
Para cada host de servidor, agregue la configuración de parámetros para especificar la cantidad de tareas paralelas que este servidor puede proporcionar. njob = N
Compilación distribuida de proyectos de Android
El servicio de compilación distribuida proporcionado por xmake es completamente multiplataforma y admite Windows, Linux, macOS, Android, iOS e incluso compilación cruzada.
Si desea compilar el proyecto de Android, solo necesita agregar la configuración de la cadena de herramientas en la configuración del servidor y proporcionar la ruta del NDK. toolchains
$ cat ~/.xmake/service/server.conf
{
distcc_build = {
listen = "0.0.0.0:9693",
toolchains = {
ndk = {
ndk = "~/files/android-ndk-r21e" <------------ here
}
},
workdir = "/Users/ruki/.xmake/service/server/distcc_build"
},
known_hosts = { },
logfile = "/Users/ruki/.xmake/service/server/logs.txt",
tokens = {
"590234653af52e91b9e438ed860f1a2b"
}
}
Luego, podemos compilar el proyecto de Android de forma distribuida como una compilación local normal, e incluso configurar varios hosts de servidor de Windows, macOS, Linux y otros servidores diferentes como recursos del servicio de compilación distribuida para compilarlo.
Simplemente descargue el NDK de la plataforma correspondiente.
$ xmake f -p android --ndk=~/files/xxxx
$ xmake
Compilación distribuida de proyectos de iOS
Compilar proyectos de iOS es más fácil, porque Xmake generalmente puede detectar Xcode automáticamente, así que simplemente cambie la plataforma a ios como un local normal.
$ xmake f -p iphoneos
$ xmake
Configuración de compilación cruzada distribuida
Si queremos distribuir la compilación cruzada, debemos configurar la ruta del sdk de la cadena de herramientas en el lado del servidor, por ejemplo:
$ cat ~/.xmake/service/server.conf
{
distcc_build = {
listen = "0.0.0.0:9693",
toolchains = {
cross = {
sdkdir = "~/files/arm-linux-xxx" <------------ here
}
},
workdir = "/Users/ruki/.xmake/service/server/distcc_build"
},
known_hosts = { },
logfile = "/Users/ruki/.xmake/service/server/logs.txt",
tokens = {
"590234653af52e91b9e438ed860f1a2b"
}
}
Entre ellos, en cadenas de herramientas, cada elemento corresponde a una cadena de herramientas, que aquí se configura como una cadena de herramientas cruzada . cross = {} toolchain("cross")
En la cadena de herramientas, podemos configurar , , etc., correspondientes a , y otras configuraciones de interfaz dentro de . sdkdir bindir cross toolchain("cross") set_sdkdir set_bindir set_cross
Si la cadena de herramientas cruzada está más estandarizada, generalmente solo necesitamos configurar y xmake puede detectarlo automáticamente. sdkdir
La compilación del lado del cliente solo necesita especificar el directorio sdk.
$ xmake f -p cross --sdk=/xxx/arm-linux-xxx
$ xmake
borrar caché del servidor
La compilación de cada proyecto en el lado del servidor generará algunos archivos de caché, que se almacenan de acuerdo con la granularidad del proyecto.Podemos usar el siguiente comando para borrar el caché correspondiente a cada servidor para el proyecto actual.
$ xmake service --clean --distcc
algunas optimizaciones internas
- Caché de resultados de compilación del lado del servidor para evitar compilaciones repetidas
- Caché local, optimización de caché remota, evita la comunicación innecesaria con el servidor
- Programación de equilibrio de carga del servidor, asignación racional de los recursos del servidor
- Los archivos pequeños se compilan directamente localmente después del preprocesamiento, que suele ser más rápido
- Compresión y transmisión en tiempo real de archivos grandes, basada en la compresión rápida lz4
- El mantenimiento de estado interno, en comparación con herramientas independientes como distcc, evita la carga frecuente de procesos independientes y el consumo de tiempo, y evita la comunicación adicional con el proceso daemon.
Soporte de caché de compilación local
De forma predeterminada, Xmake habilitará el caché local. La versión anterior a la 2.6.5 usa el caché externo de forma predeterminada, y después de la 2.6.6, Xmake proporciona una solución de caché local multiplataforma integrada.
En comparación con los procesos independientes de terceros, como ccache, el mantenimiento del estado interno de xmake es más fácil de optimizar y también evita la carga frecuente de procesos independientes y el consumo de tiempo, y evita la comunicación adicional con el proceso daemon.
Además, la memoria caché integrada puede admitir mejor las plataformas cruzadas, y msvc en Windows también puede admitirlo bien, mientras que ccache solo admite gcc/clang.
Por supuesto, también podemos deshabilitar el caché con el siguiente comando.
$ xmake f --ccache=n
Nota: Ya sea que se use o no el caché local incorporado, el nombre de configuración significa caché de compilación c/c++, no solo el nombre de la herramienta ccache. --ccache=
Si queremos seguir usando otras herramientas de almacenamiento externo en caché, también podemos configurarlo de la siguiente manera.
$ xmake f --ccache=n --cxx="ccache gcc" --cc="ccache gcc"
$ xmake
Soporte de caché de compilación remota
Además del caché local, también brindamos un servicio de caché remoto, similar al sscache de mozilla, si es solo para desarrollo personal, generalmente no se usa.
Sin embargo, si un proyecto a gran escala es desarrollado en colaboración por varias personas dentro de la empresa, la compilación distribuida y el almacenamiento en caché local por sí solos no son suficientes. También necesitamos almacenar en caché los archivos de objetos compilados en un servidor separado para compartir.
De esta manera, incluso si otras personas lo compilan por primera vez, no necesitan compilarlo de manera distribuida cada vez y extraer directamente el caché del control remoto para acelerar la compilación.
Además, el servicio de caché remoto proporcionado por Xmake también es compatible con todas las plataformas, no solo con gcc/clang sino también con msvc.
iniciar el servicio
Podemos especificar un parámetro para habilitar el servicio de caché de compilación remota, por supuesto, si no se especifica este parámetro, xmake habilitará todos los servicios configurados en el servidor de forma predeterminada. --ccache
$ xmake service --ccache
<remote_cache_server>: listening 0.0.0.0:9092 ..
También podemos iniciar el servicio y hacer eco de la información de registro detallada.
$ xmake service --ccache -vD
<remote_cache_server>: listening 0.0.0.0:9092 ..
Inicie el servicio en modo Daemon
$ xmake service --ccache --start
$ xmake service --ccache --restart
$ xmake service --ccache --stop
Configurar el servidor
Primero, ejecutamos el comando, generará automáticamente un archivo de configuración predeterminado, almacenará en . xmake service server.conf ~/.xmake/service/server.conf
$ xmake service
generating the config file to /Users/ruki/.xmake/service/server.conf ..
an token(590234653af52e91b9e438ed860f1a2b) is generated, we can use this token to connect service.
generating the config file to /Users/ruki/.xmake/service/client.conf ..
<remote_cache_server>: listening 0.0.0.0:9692 ..
Luego, lo editamos, arreglando el puerto de escucha del servidor (opcional).
$ cat ~/.xmake/service/server.conf
{
distcc_build = {
listen = "0.0.0.0:9692",
workdir = "/Users/ruki/.xmake/service/server/remote_cache"
},
known_hosts = { },
logfile = "/Users/ruki/.xmake/service/server/logs.txt",
tokens = {
"590234653af52e91b9e438ed860f1a2b"
}
}
Configurar el cliente
El archivo de configuración del cliente está ahí , podemos configurar la dirección del servidor a la que el cliente necesita conectarse. ~/.xmake/service/client.conf
Podemos configurar varias direcciones de servidor y tokens correspondientes en la lista de hosts.
$cat ~/.xmake/service/client.conf
{
remote_cache = {
connect = "127.0.0.1:9692,
token = "590234653af52e91b9e438ed860f1a2b"
}
}
}
conectarse al servidor
Después de configurar la autenticación y la dirección del servidor, puede ingresar el siguiente comando para conectar el proyecto actual al servidor configurado.
Al conectarnos, debemos ingresar y especificar que solo el servicio de caché de compilación remota está conectado. --ccache
$ cd projectdir
$ xmake service --connect --ccache
<client>: connect 127.0.0.1:9692 ..
<client>: 127.0.0.1:9692 connected!
También podemos conectarnos a múltiples servicios al mismo tiempo, como la compilación distribuida y los servicios de caché de compilación remota.
$ xmake service --connect --distcc --ccache
!> Si no hay ningún parámetro, la conexión por defecto es el servicio de compilación remota.
Desconectar
$ xmake service --disconnect --ccache
borrar caché del servidor
También podemos usar el siguiente comando para borrar el caché en el servidor remoto correspondiente al proyecto actual.
$ xmake service --clean --ccache
Y si lo ejecutamos , en el estado de conexión al servicio remoto, también borrará automáticamente todas las cachés. xmake clean --all
algunas optimizaciones internas
- Extraiga la instantánea de la memoria caché remota y envíela de vuelta al local a través del filtro bloom + lz4, que se utiliza para determinar rápidamente si existe la memoria caché y evitar consultar con frecuencia la información de la memoria caché del servidor.
- Con el caché local, puede evitar solicitudes frecuentes al servidor remoto y extraer el caché.
- El mantenimiento de estado interno, en comparación con herramientas independientes como sscache, evita la carga frecuente de procesos independientes y el consumo de tiempo, y evita la comunicación adicional con demonios.
Soporte de ingeniería Keil/C51
Solo necesitamos vincularnos a la cadena de herramientas c51, Xmake puede detectar automáticamente el entorno de la cadena de herramientas Keil/C51 SDK instalado en el sistema y luego usarlo para compilar.
target("hello")
add_rules("c51.binary")
set_toolchains("c51")
add_files("src/main.c")
Por supuesto, si no configuramos la cadena de herramientas, también podemos cambiar a la cadena de herramientas c51 manualmente. set_toolchains("c51") xmake f --toolchain=c51
actualizar contenido
nuevas características
- #2327 : Compatibilidad con el compilador nvc/nvc++/nvfortran en la cadena de herramientas nvidia-hpc-sdk
- Agregar interfaz de instancia de ruta
- #2334 : Agregar módulo de compresión lz4
- #2349 : Agregar soporte para proyectos keil/c51
- #274 : Soporte de compilación distribuida multiplataforma
- Use el caché local incorporado en lugar de ccache
Mejorar
- #2309 : La compilación remota admite la verificación de autorización de usuario
- Mejore la compilación remota, agregue soporte para compresión lz4
Corrección de errores
- Solucione el bloqueo causado por la pila lua desequilibrada al seleccionar la versión del paquete