CPack preinstall目标作用是什么？CMake项目打包deb耗时久咨询

Let's break down what's happening here—your observation makes total sense: manual dpkg-deb is lightning fast, but CPack's preinstall step feels like it's redoing half the work. Let's unpack this.

What exactly is CPack's preinstall target? #

CPack's preinstall step is the behind-the-scenes work it does to prepare a clean, isolated temporary installation directory before creating the .deb package. Unlike when you run make install directly (which installs to your system or a specified DESTDIR), CPack needs a self-contained directory with exactly the files that should go into the deb—no extra build artifacts, no leftover files from previous runs.

To get this directory, CPack triggers the full install target of your CMake project, but directs all outputs to its own temporary folder (usually under _CPack_Packages in your build directory). This isn't just copying files: it runs all your CMake install() directives, sets file permissions, executes any install-time scripts (install(CODE) or install(SCRIPT)), and ensures dependencies like shared libraries are included correctly.

Why is this taking so long (10 extra minutes)? #

The core issue is that when you run make package, CPack isn't just packaging files you already built with make—it's essentially re-running a full make install into its temporary directory. Here's why that adds so much time:

• Redundant build/installation work: If your make run only built binaries but didn't execute install, the preinstall step will trigger both remaining build steps (if any) and the full installation process. Even if you completed make fully, CPack might not reuse already-built files if your CMake dependencies aren't set up to recognize that the install target only needs built artifacts, not a rebuild.
• Temporary directory overhead: CPack creates a fresh temporary directory every time, so it has to copy all your project's files (binaries, libraries, configs, docs, etc.) from the build directory to this temp folder. While this adds up for large projects, your note that dpkg-deb is fast means this is probably not the main culprit.
• Custom install scripts: If your CMake project uses install(CODE) or install(SCRIPT) to run custom logic during installation (like generating config files, modifying permissions, or compiling small helper tools), all that logic runs again during preinstall. Slow scripts here will drag out the process significantly.
• Deb-specific prep: CPack also handles deb-specific setup (creating DEBIAN control files, managing dependencies, setting up postinst/prerm scripts), but this is usually quick compared to a full install.

Contrast this with manual dpkg-deb: when you run that, you're already providing a fully structured directory (with the DEBIAN folder and all correct files in place). You've done the "install" work manually, so dpkg-deb just wraps it up—no extra steps needed.

How can you speed this up? #

Here are practical fixes to cut down that preinstall time:

1. Separate build and install before packaging
   First build all binaries with make, then explicitly run make install into a temporary directory:

   make
   TEMP_INSTALL=$(mktemp -d)
   make install DESTDIR=$TEMP_INSTALL
   

   Then tell CPack to package this pre-prepared directory instead of running its own preinstall:

   cpack -G DEB -D CPACK_INSTALL_DIRECTORY=$TEMP_INSTALL
   

   This skips CPack's internal preinstall step entirely, since you've already set up the directory.

2. Ensure CMake doesn't rebuild during install
   Check your CMakeLists.txt to make sure the install target only depends on built artifacts (binaries, libraries) and not unnecessary targets. Remove any redundant dependencies so make install (and thus CPack's preinstall) only copies files, not rebuilds anything.

3. Optimize custom install scripts
   Audit any install(CODE) or install(SCRIPT) directives. For example, if a script generates a static config file that doesn't change between builds, pre-generate it during the build step instead of during install.

4. Reuse a persistent temporary directory (carefully)
   If you're packaging multiple times in a row, tell CPack to use a persistent temp directory instead of creating a new one each time. Add this to your CMakeLists.txt:

   set(CPACK_PACKAGE_INSTALL_DIRECTORY "/path/to/reusable/temp")
   

   Just remember to clean this directory before packaging if you need a fresh build—otherwise you might get leftover files from previous runs.

内容的提问来源于stack exchange，提问作者shay