Metoda 1: Instalarea CMake cu DNF

Instalati CMake din Rocky Linux AppStream:

sudo dnf install cmake

DNF instaleaza pachetul principal cmake plus pachete de suport precum cmake-data si cmake-filesystem. Pe versiunile curente Rocky, tranzactia instaleaza si make cand nu este deja instalat, dar nu instaleaza compilatorul C++.

Instalarea instrumentelor de build pentru proiecte C++

CMake genereaza fisiere de build, dar nu inlocuieste un compilator. Instalati compilatorul C++ si Make daca planificati sa compilati proiecte C++ locale sau sa rulati proiectul de test dupa instalare:

sudo dnf install gcc-c++ make

Verificarea CMake pe Rocky Linux

Confirmati ca comanda este disponibila:

cmake --version

Rocky Linux 10 returneaza in prezent:

cmake version 3.30.5

CMake suite maintained and supported by Kitware (kitware.com/cmake).

Rocky Linux 9 si 8 returneaza in prezent seria 3.26 din AppStream:

cmake version 3.26.5

CMake suite maintained and supported by Kitware (kitware.com/cmake).

Verificati revizia exacta RPM cand un proiect sau raport de bug intreaba ce build Rocky folositi:

Metoda 2: Instalarea CMake upstream Kitware pe Rocky Linux

Folositi binarul upstream Kitware doar cand pachetul Rocky este prea vechi pentru proiectul pe care trebuie sa il compilati. Aceasta metoda functioneaza pe sisteme Rocky Linux x86_64 si aarch64 deoarece Kitware publica arhive Linux pentru ambele arhitecturi.

Instalarea cerintelor helper-ului upstream

Instalati instrumentele mici folosite de helper-ul de actualizare:

sudo dnf install curl python3 tar gzip

Crearea helper-ului de actualizare CMake upstream

Creati un helper reutilizabil care detecteaza cel mai recent tag CMake non-prerelease din GitHub, mapeaza arhitectura Rocky Linux la numele arhivei Kitware, verifica checksum-ul SHA-256, inlocuieste prefixul dedicat si reimprospazeaza symlink-urile de comenzi:

sudo tee /usr/local/bin/update-cmake-upstream >/dev/null <<'EOF'
#!/usr/bin/env bash
set -euo pipefail

if [ "$(id -u)" -ne 0 ]; then
    echo "Run this helper with sudo: sudo /usr/local/bin/update-cmake-upstream" >&2
    exit 1
fi

prefix=/opt/cmake-upstream
bin_dir=/usr/local/bin
release_api=https://api.github.com/repos/Kitware/CMake/releases/latest

cmake_ver=$(curl -fsSL "$release_api" | python3 -c 'import json, sys; print(json.load(sys.stdin)["tag_name"].lstrip("v"))')

case "$(uname -m)" in
x86_64) cmake_arch=linux-x86_64 ;;
aarch64 | arm64) cmake_arch=linux-aarch64 ;;
*)
    printf 'Unsupported architecture: %s\n' "$(uname -m)" >&2
    exit 1
    ;;
esac

archive="cmake-${cmake_ver}-${cmake_arch}.tar.gz"
checksum_file="cmake-${cmake_ver}-SHA-256.txt"
base_url="https://github.com/Kitware/CMake/releases/download/v${cmake_ver}"

guard_links() {
    for tool in cmake ctest cpack; do
        link="${bin_dir}/${tool}"
        expected="${prefix}/bin/${tool}"
        if [ -L "$link" ]; then
            current_target=$(readlink "$link")
            if [ "$current_target" != "$expected" ]; then
                printf 'Refusing to replace %s because it points to %s.\n' "$link" "$current_target" >&2
                exit 1
            fi
        elif [ -e "$link" ]; then
            printf 'Refusing to overwrite %s because it is not a symlink.\n' "$link" >&2
            exit 1
        fi
    done
}

refresh_links() {
    for tool in cmake ctest cpack; do
        ln -sfn "${prefix}/bin/${tool}" "${bin_dir}/${tool}"
    done
}

guard_links

current_ver=""
if [ -x "${prefix}/bin/cmake" ]; then
    current_ver=$("${prefix}/bin/cmake" --version | awk '/^cmake version/ {print $3; exit}')
fi

if [ "$current_ver" = "$cmake_ver" ]; then
    refresh_links
    printf 'CMake %s is already installed.\n' "$cmake_ver"
    exit 0
fi

work_dir=$(mktemp -d)
old_prefix=""

restore_old_prefix() {
    if [ -n "$old_prefix" ] && [ -e "$old_prefix" ] && [ ! -e "$prefix" ]; then
        mv "$old_prefix" "$prefix"
    fi
}

cleanup() {
    status=$?
    restore_old_prefix
    rm -rf "$work_dir"
    exit "$status"
}

trap cleanup EXIT
cd "$work_dir"

curl -fsSLO "${base_url}/${archive}"
curl -fsSLO "${base_url}/${checksum_file}"
grep " ${archive}$" "$checksum_file" | sha256sum -c -

install_dir="${work_dir}/cmake-upstream"
mkdir -p "$install_dir"
tar -xzf "$archive" --strip-components=1 -C "$install_dir"
"${install_dir}/bin/cmake" --version >/dev/null

if [ -e "$prefix" ] && [ ! -d "$prefix" ]; then
    printf 'Refusing to replace %s because it is not a directory.\n' "$prefix" >&2
    exit 1
fi

if [ -d "$prefix" ]; then
    old_prefix="${prefix}.previous.$(date +%s)"
    mv "$prefix" "$old_prefix"
fi

mv "$install_dir" "$prefix"
refresh_links
if [ -n "$old_prefix" ]; then
    rm -rf "$old_prefix"
    old_prefix=""
fi

"${prefix}/bin/cmake" --version
EOF

Faceti helper-ul executabil:

sudo chmod 755 /usr/local/bin/update-cmake-upstream
command -v update-cmake-upstream
/usr/local/bin/update-cmake-upstream

Instalarea CMake upstream cu helper-ul

Helper-ul inlocuieste directorul /opt/cmake-upstream folosit de aceasta metoda si reimprospazeaza symlink-urile sale din /usr/local/bin.

ATENTIE: Faceti backup la orice ati adaugat manual sub acel director inainte de a-l rula.

sudo /usr/local/bin/update-cmake-upstream

Exemplu de output pentru versiunea curenta x86_64 (numarul de versiune poate diferi):

cmake-4.3.2-linux-x86_64.tar.gz: OK
cmake version 4.3.2

CMake suite maintained and supported by Kitware (kitware.com/cmake).

Verificarea CMake upstream pe Rocky Linux

Verificati comanda upstream direct din /usr/local/bin:

/usr/local/bin/cmake --version

Testarea CMake cu un proiect C++ mic

Un build mic dovedeste ca CMake, compilatorul si Make functioneaza impreuna. Creati un director de test curat si scrieti un fisier sursa C++ minimal:

mkdir -p ~/cmake-test
cd ~/cmake-test

cat > main.cpp <<'EOF'
#include <iostream>

int main() {
    std::cout << "CMake is working!" << std::endl;
    return 0;
}
EOF

Creati un fisier CMakeLists.txt de baza pentru proiect:

cat > CMakeLists.txt <<'EOF'
cmake_minimum_required(VERSION 3.10)
project(HelloCMake LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 17)
add_executable(hello main.cpp)
EOF

Configurati si compilati proiectul:

cmake -S . -B build -G "Unix Makefiles"
cmake --build build

Rulati binarul de test compilat:

./build/hello

Programul trebuie sa afiseze:

CMake is working!

Eliminati proiectul de test cand nu mai aveti nevoie de el:

Actualizarea CMake pe Rocky Linux

Actualizarea pachetului Rocky CMake

Pachetul AppStream se actualizeaza odata cu mentenanta normala a sistemului. Folositi un upgrade targetat cand doriti sa verificati doar CMake si dependentele sale:

sudo dnf upgrade cmake

Dupa upgrade, reverificati versiunea:

cmake --version

Actualizarea CMake upstream

Pentru metoda upstream Kitware, reexecutati helper-ul. Verifica cea mai recenta versiune, verifica arhiva corespunzatoare, inlocuieste /opt/cmake-upstream cand este disponibila o versiune mai noua si iese curat cand versiunea curenta este deja instalata:

sudo /usr/local/bin/update-cmake-upstream

Daca versiunea upstream instalata este deja curenta, helper-ul returneaza o linie scurta de status. Daca Kitware a publicat o versiune mai noua, afiseaza in schimb rezultatul checksum-ului si noul banner cmake --version.

Eliminarea CMake din Rocky Linux

Eliminarea pachetului Rocky CMake

Eliminati pachetul gestionat de Rocky cu DNF:

sudo dnf remove cmake

Verificati ca pachetul nu mai este instalat:

rpm -q cmake || true
package cmake is not installed

Daca ati instalat gcc-c++ si make doar pentru proiectul de test, eliminati-le separat dupa confirmarea ca niciun alt build local nu are nevoie de ele:

sudo dnf remove gcc-c++ make

Eliminarea CMake upstream

Comenzile urmatoare sterg permanent prefixul CMake upstream si elimina doar symlink-urile care pointeaza inca catre acel prefix. Nu elimina pachetul Rocky de sub /usr/bin daca l-ati instalat separat:

for tool in cmake ctest cpack; do
    link="/usr/local/bin/$tool"
    target="/opt/cmake-upstream/bin/$tool"
    if [ -L "$link" ] && [ "$(readlink "$link")" = "$target" ]; then
        sudo rm -f "$link"
    fi
done

sudo rm -rf /opt/cmake-upstream
sudo rm -f /usr/local/bin/update-cmake-upstream
hash -r
command -v update-cmake-upstream || echo "update-cmake-upstream command not found"
command -v cmake || echo "cmake command not found"

Verificarea eliminarii helper-ului trebuie sa afiseze update-cmake-upstream command not found. Daca pachetul Rocky ramane instalat, verificarea finala CMake trebuie sa returneze /usr/bin/cmake. Daca nicio metoda CMake nu ramane instalata, afiseaza cmake command not found.

Depanare probleme CMake pe Rocky Linux

Comanda CMake nu este gasita

Daca shell-ul nu gaseste CMake, fie pachetul lipseste, fie shell-ul curent are in continuare o cale de comanda veche in cache:

bash: cmake: command not found

Verificati atat starea RPM cat si calea shell-ului:

rpm -q cmake || true
command -v cmake || echo "cmake missing from PATH"

Cand CMake lipseste, diagnosticul returneaza:

package cmake is not installed
cmake missing from PATH

Instalati pachetul Rocky, curatati cache-ul de comenzi Bash si reverificati versiunea:

sudo dnf install cmake
hash -r
cmake --version

CMake nu gaseste un compilator C++

CMake poate genera fisiere de build doar dupa ce gaseste compilatorul pe care il necesita limbajul proiectului. Un compilator C++ lipsa apare frecvent in timpul project(... LANGUAGES CXX) sau al primului pas de configurare.

Verificati daca Rocky Linux poate gasi comanda compilatorului C++:

command -v c++ || echo "c++ compiler missing"

Un compilator lipsa returneaza:

c++ compiler missing

Instalati toolchain-ul C++ si reexecutati CMake dintr-un director de build nou:

sudo dnf install gcc-c++ make
cmake -S . -B build-fresh -G "Unix Makefiles"

Proiectul necesita o versiune CMake mai noua

Unele proiecte declara o versiune minima CMake mai noua decat pachetul Rocky. O eroare tipica arata astfel:

CMake 3.28 or higher is required. You are running version 3.26.5

Rocky Linux 9 si 8 livreaza in prezent CMake 3.26.x, deci proiectele care necesita 3.28 sau mai nou au nevoie de metoda upstream sau de o solutie alternativa suportata de proiect. Rocky Linux 10 livreaza in prezent CMake 3.30.x, deci comutati metodele acolo doar cand proiectul necesita o versiune 4.x mai noua sau o versiune specifica Kitware.

Dupa instalarea metodei upstream, verificati versiunea care satisface cerinta proiectului:

/usr/local/bin/cmake --version

Versiuni multiple CMake in PATH

Daca ati instalat ambele metode, verificati ce binar rezolva shell-ul primul:

command -v cmake
cmake --version

Daca helper-ul upstream castiga in PATH, rezultatul incepe astfel:

/usr/local/bin/cmake
cmake version 4.3.2

Pachetele Rocky folosesc /usr/bin/cmake, iar helper-ul upstream creeaza /usr/local/bin/cmake. Eliminati metoda pe care nu o doriti, apoi deschideti un shell nou sau rulati hash -r inainte de a verifica din nou.

Utilizarea documentatiei CMake dupa instalare

Documentatia oficiala CMake acopera comenzi precum cmake --build, preset-uri, fisiere toolchain, descoperirea pachetelor cu find_package(), CTest si CPack. Folositi documentatia corespunzatoare versiunii sau ajutorul local cand va bazati pe o functie care poate fi mai noua decat CMake-ul ambalat de Rocky.

Ajutorul local provine din versiunea CMake aflata prima in PATH: