Merge pull request #33664 from ClickHouse/release-steps

Refactor releasing process
2024-11-21 23:21:59 +00:00 · 2022-03-22 14:43:18 +01:00 · 2022-03-22 14:43:18 +01:00 · 0ab9a9c0f6
commit 0ab9a9c0f6
parent 0576c1b0f3 d2e10cfa87
25 changed files with 1026 additions and 182 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -267,7 +267,10 @@ endif ()

 # Allows to build stripped binary in a separate directory
 if (OBJCOPY_PATH AND READELF_PATH)
-    set(BUILD_STRIPPED_BINARIES_PREFIX "" CACHE STRING "Build stripped binaries with debug info in separate directory")
+    option(INSTALL_STRIPPED_BINARIES "Build stripped binaries with debug info in separate directory" OFF)
+    if (INSTALL_STRIPPED_BINARIES)
+        set(STRIPPED_BINARIES_OUTPUT "stripped" CACHE STRING "A separate directory for stripped information")
+    endif()
 endif()

 cmake_host_system_information(RESULT AVAILABLE_PHYSICAL_MEMORY QUERY AVAILABLE_PHYSICAL_MEMORY) # Not available under freebsd
--- a/cmake/strip.sh
+++ b/cmake/strip.sh
@ -1,15 +1,14 @@
 #!/usr/bin/env bash

 BINARY_PATH=$1
-BINARY_NAME=$(basename $BINARY_PATH)
+BINARY_NAME=$(basename "$BINARY_PATH")
 DESTINATION_STRIPPED_DIR=$2
 OBJCOPY_PATH=${3:objcopy}
 READELF_PATH=${4:readelf}

-BUILD_ID=$($READELF_PATH -n $1 | sed -n '/Build ID/ { s/.*: //p; q; }')
+BUILD_ID=$($READELF_PATH -n "$1" | sed -n '/Build ID/ { s/.*: //p; q; }')
 BUILD_ID_PREFIX=${BUILD_ID:0:2}
 BUILD_ID_SUFFIX=${BUILD_ID:2}
-TEMP_BINARY_PATH="${BINARY_PATH}_temp"

 DESTINATION_DEBUG_INFO_DIR="$DESTINATION_STRIPPED_DIR/lib/debug/.build-id"
 DESTINATION_STRIP_BINARY_DIR="$DESTINATION_STRIPPED_DIR/bin"
@ -17,9 +16,13 @@ DESTINATION_STRIP_BINARY_DIR="$DESTINATION_STRIPPED_DIR/bin"
 mkdir -p "$DESTINATION_DEBUG_INFO_DIR/$BUILD_ID_PREFIX"
 mkdir -p "$DESTINATION_STRIP_BINARY_DIR"

-$OBJCOPY_PATH --only-keep-debug "$BINARY_PATH" "$DESTINATION_DEBUG_INFO_DIR/$BUILD_ID_PREFIX/$BUILD_ID_SUFFIX.debug"

-touch "$TEMP_BINARY_PATH"
-$OBJCOPY_PATH --add-gnu-debuglink "$DESTINATION_DEBUG_INFO_DIR/$BUILD_ID_PREFIX/$BUILD_ID_SUFFIX.debug" "$BINARY_PATH" "$TEMP_BINARY_PATH"
-$OBJCOPY_PATH --strip-all "$TEMP_BINARY_PATH" "$DESTINATION_STRIP_BINARY_DIR/$BINARY_NAME"
-rm -f "$TEMP_BINARY_PATH"
+cp "$BINARY_PATH" "$DESTINATION_STRIP_BINARY_DIR/$BINARY_NAME"
+
+$OBJCOPY_PATH --only-keep-debug --compress-debug-sections "$DESTINATION_STRIP_BINARY_DIR/$BINARY_NAME" "$DESTINATION_DEBUG_INFO_DIR/$BUILD_ID_PREFIX/$BUILD_ID_SUFFIX.debug"
+chmod 0644 "$DESTINATION_DEBUG_INFO_DIR/$BUILD_ID_PREFIX/$BUILD_ID_SUFFIX.debug"
+chown 0:0 "$DESTINATION_DEBUG_INFO_DIR/$BUILD_ID_PREFIX/$BUILD_ID_SUFFIX.debug"
+
+strip --remove-section=.comment --remove-section=.note "$DESTINATION_STRIP_BINARY_DIR/$BINARY_NAME"
+
+$OBJCOPY_PATH --add-gnu-debuglink "$DESTINATION_DEBUG_INFO_DIR/$BUILD_ID_PREFIX/$BUILD_ID_SUFFIX.debug" "$DESTINATION_STRIP_BINARY_DIR/$BINARY_NAME"
--- a/docker/packager/binary/Dockerfile
+++ b/docker/packager/binary/Dockerfile
@ -95,6 +95,14 @@ RUN add-apt-repository ppa:ubuntu-toolchain-r/test --yes \
    && apt-get install gcc-11 g++-11 --yes \
    && apt-get clean

+# Architecture of the image when BuildKit/buildx is used
+ARG TARGETARCH
+ARG NFPM_VERSION=2.15.0
+
+RUN arch=${TARGETARCH:-amd64} \
+  && curl -Lo /tmp/nfpm.deb "https://github.com/goreleaser/nfpm/releases/download/v${NFPM_VERSION}/nfpm_${arch}.deb" \
+  && dpkg -i /tmp/nfpm.deb \
+  && rm /tmp/nfpm.deb

 COPY build.sh /
-CMD ["bash", "-c", "/build.sh 2>&1 | ts"]
+CMD ["bash", "-c", "/build.sh 2>&1"]
--- a/docker/packager/binary/build.sh
+++ b/docker/packager/binary/build.sh
@ -1,7 +1,13 @@
 #!/usr/bin/env bash

+exec &> >(ts)
 set -x -e

+cache_status () {
+    ccache --show-config ||:
+    ccache --show-stats ||:
+}
+
 mkdir -p build/cmake/toolchain/darwin-x86_64
 tar xJf MacOSX11.0.sdk.tar.xz -C build/cmake/toolchain/darwin-x86_64 --strip-components=1
 ln -sf darwin-x86_64 build/cmake/toolchain/darwin-aarch64
@ -19,15 +25,23 @@ read -ra CMAKE_FLAGS <<< "${CMAKE_FLAGS:-}"
 env
 cmake --debug-trycompile --verbose=1 -DCMAKE_VERBOSE_MAKEFILE=1 -LA "-DCMAKE_BUILD_TYPE=$BUILD_TYPE" "-DSANITIZE=$SANITIZER" -DENABLE_CHECK_HEAVY_BUILDS=1 "${CMAKE_FLAGS[@]}" ..

-ccache --show-config ||:
-ccache --show-stats ||:
+cache_status
+# clear cache stats
 ccache --zero-stats ||:

-# shellcheck disable=SC2086 # No quotes because I want it to expand to nothing if empty.
+# No quotes because I want it to expand to nothing if empty.
+# shellcheck disable=SC2086
 ninja $NINJA_FLAGS clickhouse-bundle

-ccache --show-config ||:
-ccache --show-stats ||:
+cache_status
+
+if [ -n "$MAKE_DEB" ]; then
+  rm -rf /build/packages/root
+  # No quotes because I want it to expand to nothing if empty.
+  # shellcheck disable=SC2086
+  DESTDIR=/build/packages/root ninja $NINJA_FLAGS install
+  bash -x /build/packages/build
+fi

 mv ./programs/clickhouse* /output
 mv ./src/unit_tests_dbms /output ||: # may not exist for some binary builds
@ -84,8 +98,7 @@ fi
 #   ../docker/packager/other/fuzzer.sh
 # fi

-ccache --show-config ||:
-ccache --show-stats ||:
+cache_status

 if [ "${CCACHE_DEBUG:-}" == "1" ]
 then
--- a/docker/packager/packager
+++ b/docker/packager/packager
@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-#-*- coding: utf-8 -*-
+# -*- coding: utf-8 -*-
 import subprocess
 import os
 import argparse
@ -8,36 +8,39 @@ import sys

 SCRIPT_PATH = os.path.realpath(__file__)

-IMAGE_MAP = {
-    "deb": "clickhouse/deb-builder",
-    "binary": "clickhouse/binary-builder",
-}

 def check_image_exists_locally(image_name):
    try:
-        output = subprocess.check_output("docker images -q {} 2> /dev/null".format(image_name), shell=True)
+        output = subprocess.check_output(
+            f"docker images -q {image_name} 2> /dev/null", shell=True
+        )
        return output != ""
-    except subprocess.CalledProcessError as ex:
+    except subprocess.CalledProcessError:
        return False

+
 def pull_image(image_name):
    try:
-        subprocess.check_call("docker pull {}".format(image_name), shell=True)
+        subprocess.check_call(f"docker pull {image_name}", shell=True)
        return True
-    except subprocess.CalledProcessError as ex:
-        logging.info("Cannot pull image {}".format(image_name))
+    except subprocess.CalledProcessError:
+        logging.info(f"Cannot pull image {image_name}".format())
        return False

+
 def build_image(image_name, filepath):
    context = os.path.dirname(filepath)
-    build_cmd = "docker build --network=host -t {} -f {} {}".format(image_name, filepath, context)
-    logging.info("Will build image with cmd: '{}'".format(build_cmd))
+    build_cmd = f"docker build --network=host -t {image_name} -f {filepath} {context}"
+    logging.info("Will build image with cmd: '%s'", build_cmd)
    subprocess.check_call(
        build_cmd,
        shell=True,
    )

-def run_docker_image_with_env(image_name, output, env_variables, ch_root, ccache_dir, docker_image_version):
+
+def run_docker_image_with_env(
+    image_name, output, env_variables, ch_root, ccache_dir, docker_image_version
+):
    env_part = " -e ".join(env_variables)
    if env_part:
        env_part = " -e " + env_part
@ -47,28 +50,52 @@ def run_docker_image_with_env(image_name, output, env_variables, ch_root, ccache
    else:
        interactive = ""

-    cmd = "docker run --network=host --rm --volume={output_path}:/output --volume={ch_root}:/build --volume={ccache_dir}:/ccache {env} {interactive} {img_name}".format(
-        output_path=output,
-        ch_root=ch_root,
-        ccache_dir=ccache_dir,
-        env=env_part,
-        img_name=image_name + ":" + docker_image_version,
-        interactive=interactive
+    cmd = (
+        f"docker run --network=host --rm --volume={output}:/output "
+        f"--volume={ch_root}:/build --volume={ccache_dir}:/ccache {env_part} "
+        f"{interactive} {image_name}:{docker_image_version}"
    )

-    logging.info("Will build ClickHouse pkg with cmd: '{}'".format(cmd))
+    logging.info("Will build ClickHouse pkg with cmd: '%s'", cmd)

    subprocess.check_call(cmd, shell=True)

-def parse_env_variables(build_type, compiler, sanitizer, package_type, image_type, cache, distcc_hosts, split_binary, clang_tidy, version, author, official, alien_pkgs, with_coverage, with_binaries):
+
+def is_release_build(build_type, package_type, sanitizer, split_binary):
+    return (
+        build_type == ""
+        and package_type == "deb"
+        and sanitizer == ""
+        and not split_binary
+    )
+
+
+def parse_env_variables(
+    build_type,
+    compiler,
+    sanitizer,
+    package_type,
+    image_type,
+    cache,
+    distcc_hosts,
+    split_binary,
+    clang_tidy,
+    version,
+    author,
+    official,
+    additional_pkgs,
+    with_coverage,
+    with_binaries,
+):
    DARWIN_SUFFIX = "-darwin"
    DARWIN_ARM_SUFFIX = "-darwin-aarch64"
    ARM_SUFFIX = "-aarch64"
    FREEBSD_SUFFIX = "-freebsd"
-    PPC_SUFFIX = '-ppc64le'
+    PPC_SUFFIX = "-ppc64le"

    result = []
-    cmake_flags = ['$CMAKE_FLAGS']
+    result.append("OUTPUT_DIR=/output")
+    cmake_flags = ["$CMAKE_FLAGS"]

    is_cross_darwin = compiler.endswith(DARWIN_SUFFIX)
    is_cross_darwin_arm = compiler.endswith(DARWIN_ARM_SUFFIX)
@ -77,46 +104,72 @@ def parse_env_variables(build_type, compiler, sanitizer, package_type, image_typ
    is_cross_freebsd = compiler.endswith(FREEBSD_SUFFIX)

    if is_cross_darwin:
-        cc = compiler[:-len(DARWIN_SUFFIX)]
+        cc = compiler[: -len(DARWIN_SUFFIX)]
        cmake_flags.append("-DCMAKE_AR:FILEPATH=/cctools/bin/x86_64-apple-darwin-ar")
-        cmake_flags.append("-DCMAKE_INSTALL_NAME_TOOL=/cctools/bin/x86_64-apple-darwin-install_name_tool")
-        cmake_flags.append("-DCMAKE_RANLIB:FILEPATH=/cctools/bin/x86_64-apple-darwin-ranlib")
+        cmake_flags.append(
+            "-DCMAKE_INSTALL_NAME_TOOL=/cctools/bin/"
+            "x86_64-apple-darwin-install_name_tool"
+        )
+        cmake_flags.append(
+            "-DCMAKE_RANLIB:FILEPATH=/cctools/bin/x86_64-apple-darwin-ranlib"
+        )
        cmake_flags.append("-DLINKER_NAME=/cctools/bin/x86_64-apple-darwin-ld")
-        cmake_flags.append("-DCMAKE_TOOLCHAIN_FILE=/build/cmake/darwin/toolchain-x86_64.cmake")
+        cmake_flags.append(
+            "-DCMAKE_TOOLCHAIN_FILE=/build/cmake/darwin/toolchain-x86_64.cmake"
+        )
    elif is_cross_darwin_arm:
-        cc = compiler[:-len(DARWIN_ARM_SUFFIX)]
+        cc = compiler[: -len(DARWIN_ARM_SUFFIX)]
        cmake_flags.append("-DCMAKE_AR:FILEPATH=/cctools/bin/aarch64-apple-darwin-ar")
-        cmake_flags.append("-DCMAKE_INSTALL_NAME_TOOL=/cctools/bin/aarch64-apple-darwin-install_name_tool")
-        cmake_flags.append("-DCMAKE_RANLIB:FILEPATH=/cctools/bin/aarch64-apple-darwin-ranlib")
+        cmake_flags.append(
+            "-DCMAKE_INSTALL_NAME_TOOL=/cctools/bin/"
+            "aarch64-apple-darwin-install_name_tool"
+        )
+        cmake_flags.append(
+            "-DCMAKE_RANLIB:FILEPATH=/cctools/bin/aarch64-apple-darwin-ranlib"
+        )
        cmake_flags.append("-DLINKER_NAME=/cctools/bin/aarch64-apple-darwin-ld")
-        cmake_flags.append("-DCMAKE_TOOLCHAIN_FILE=/build/cmake/darwin/toolchain-aarch64.cmake")
+        cmake_flags.append(
+            "-DCMAKE_TOOLCHAIN_FILE=/build/cmake/darwin/toolchain-aarch64.cmake"
+        )
    elif is_cross_arm:
-        cc = compiler[:-len(ARM_SUFFIX)]
-        cmake_flags.append("-DCMAKE_TOOLCHAIN_FILE=/build/cmake/linux/toolchain-aarch64.cmake")
-        result.append("DEB_ARCH_FLAG=-aarm64")
+        cc = compiler[: -len(ARM_SUFFIX)]
+        cmake_flags.append(
+            "-DCMAKE_TOOLCHAIN_FILE=/build/cmake/linux/toolchain-aarch64.cmake"
+        )
+        result.append("DEB_ARCH=arm64")
    elif is_cross_freebsd:
-        cc = compiler[:-len(FREEBSD_SUFFIX)]
-        cmake_flags.append("-DCMAKE_TOOLCHAIN_FILE=/build/cmake/freebsd/toolchain-x86_64.cmake")
+        cc = compiler[: -len(FREEBSD_SUFFIX)]
+        cmake_flags.append(
+            "-DCMAKE_TOOLCHAIN_FILE=/build/cmake/freebsd/toolchain-x86_64.cmake"
+        )
    elif is_cross_ppc:
-        cc = compiler[:-len(PPC_SUFFIX)]
-        cmake_flags.append("-DCMAKE_TOOLCHAIN_FILE=/build/cmake/linux/toolchain-ppc64le.cmake")
+        cc = compiler[: -len(PPC_SUFFIX)]
+        cmake_flags.append(
+            "-DCMAKE_TOOLCHAIN_FILE=/build/cmake/linux/toolchain-ppc64le.cmake"
+        )
    else:
        cc = compiler
-        result.append("DEB_ARCH_FLAG=-aamd64")
+        result.append("DEB_ARCH=amd64")

-    cxx = cc.replace('gcc', 'g++').replace('clang', 'clang++')
+    cxx = cc.replace("gcc", "g++").replace("clang", "clang++")

    if image_type == "deb":
-        result.append("DEB_CC={}".format(cc))
-        result.append("DEB_CXX={}".format(cxx))
-        # For building fuzzers
-        result.append("CC={}".format(cc))
-        result.append("CXX={}".format(cxx))
-    elif image_type == "binary":
-        result.append("CC={}".format(cc))
-        result.append("CXX={}".format(cxx))
-        cmake_flags.append('-DCMAKE_C_COMPILER=`which {}`'.format(cc))
-        cmake_flags.append('-DCMAKE_CXX_COMPILER=`which {}`'.format(cxx))
+        result.append("MAKE_DEB=true")
+        cmake_flags.append("-DENABLE_TESTS=0")
+        cmake_flags.append("-DENABLE_UTILS=0")
+        cmake_flags.append("-DCMAKE_EXPORT_NO_PACKAGE_REGISTRY=ON")
+        cmake_flags.append("-DCMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY=ON")
+        cmake_flags.append("-DCMAKE_AUTOGEN_VERBOSE=ON")
+        cmake_flags.append("-DCMAKE_INSTALL_PREFIX=/usr")
+        cmake_flags.append("-DCMAKE_INSTALL_SYSCONFDIR=/etc")
+        cmake_flags.append("-DCMAKE_INSTALL_LOCALSTATEDIR=/var")
+        if is_release_build(build_type, package_type, sanitizer, split_binary):
+            cmake_flags.append("-DINSTALL_STRIPPED_BINARIES=ON")
+
+    result.append(f"CC={cc}")
+    result.append(f"CXX={cxx}")
+    cmake_flags.append(f"-DCMAKE_C_COMPILER={cc}")
+    cmake_flags.append(f"-DCMAKE_CXX_COMPILER={cxx}")

    # Create combined output archive for split build and for performance tests.
    if package_type == "performance":
@ -126,12 +179,14 @@ def parse_env_variables(build_type, compiler, sanitizer, package_type, image_typ
        result.append("COMBINED_OUTPUT=shared_build")

    if sanitizer:
-        result.append("SANITIZER={}".format(sanitizer))
+        result.append(f"SANITIZER={sanitizer}")
    if build_type:
-        result.append("BUILD_TYPE={}".format(build_type))
+        result.append(f"BUILD_TYPE={build_type.capitalize()}")
+    else:
+        result.append("BUILD_TYPE=None")

-    if cache == 'distcc':
-        result.append("CCACHE_PREFIX={}".format(cache))
+    if cache == "distcc":
+        result.append(f"CCACHE_PREFIX={cache}")

    if cache:
        result.append("CCACHE_DIR=/ccache")
@ -142,109 +197,188 @@ def parse_env_variables(build_type, compiler, sanitizer, package_type, image_typ
        # result.append("CCACHE_UMASK=777")

    if distcc_hosts:
-        hosts_with_params = ["{}/24,lzo".format(host) for host in distcc_hosts] + ["localhost/`nproc`"]
-        result.append('DISTCC_HOSTS="{}"'.format(" ".join(hosts_with_params)))
+        hosts_with_params = [f"{host}/24,lzo" for host in distcc_hosts] + [
+            "localhost/`nproc`"
+        ]
+        result.append('DISTCC_HOSTS="' + " ".join(hosts_with_params) + '"')
    elif cache == "distcc":
-        result.append('DISTCC_HOSTS="{}"'.format("localhost/`nproc`"))
+        result.append('DISTCC_HOSTS="localhost/`nproc`"')

-    if alien_pkgs:
-        result.append("ALIEN_PKGS='" + ' '.join(['--' + pkg for pkg in alien_pkgs]) + "'")
+    if additional_pkgs:
+        result.append("MAKE_APK=true")
+        result.append("MAKE_RPM=true")
+        result.append("MAKE_TGZ=true")

    if with_binaries == "programs":
-        result.append('BINARY_OUTPUT=programs')
+        result.append("BINARY_OUTPUT=programs")
    elif with_binaries == "tests":
-        result.append('ENABLE_TESTS=1')
-        result.append('BINARY_OUTPUT=tests')
-        cmake_flags.append('-DENABLE_TESTS=1')
+        result.append("ENABLE_TESTS=1")
+        result.append("BINARY_OUTPUT=tests")
+        cmake_flags.append("-DENABLE_TESTS=1")

    if split_binary:
-        cmake_flags.append('-DUSE_STATIC_LIBRARIES=0 -DSPLIT_SHARED_LIBRARIES=1 -DCLICKHOUSE_SPLIT_BINARY=1')
+        cmake_flags.append(
+            "-DUSE_STATIC_LIBRARIES=0 -DSPLIT_SHARED_LIBRARIES=1 "
+            "-DCLICKHOUSE_SPLIT_BINARY=1"
+        )
        # We can't always build utils because it requires too much space, but
        # we have to build them at least in some way in CI. The split build is
        # probably the least heavy disk-wise.
-        cmake_flags.append('-DENABLE_UTILS=1')
+        cmake_flags.append("-DENABLE_UTILS=1")

    if clang_tidy:
-        cmake_flags.append('-DENABLE_CLANG_TIDY=1')
-        cmake_flags.append('-DENABLE_UTILS=1')
-        cmake_flags.append('-DENABLE_TESTS=1')
-        cmake_flags.append('-DENABLE_EXAMPLES=1')
+        cmake_flags.append("-DENABLE_CLANG_TIDY=1")
+        cmake_flags.append("-DENABLE_UTILS=1")
+        cmake_flags.append("-DENABLE_TESTS=1")
+        cmake_flags.append("-DENABLE_EXAMPLES=1")
        # Don't stop on first error to find more clang-tidy errors in one run.
-        result.append('NINJA_FLAGS=-k0')
+        result.append("NINJA_FLAGS=-k0")

    if with_coverage:
-        cmake_flags.append('-DWITH_COVERAGE=1')
+        cmake_flags.append("-DWITH_COVERAGE=1")

    if version:
-        result.append("VERSION_STRING='{}'".format(version))
+        result.append(f"VERSION_STRING='{version}'")

    if author:
-        result.append("AUTHOR='{}'".format(author))
+        result.append(f"AUTHOR='{author}'")

    if official:
-        cmake_flags.append('-DYANDEX_OFFICIAL_BUILD=1')
+        cmake_flags.append("-DYANDEX_OFFICIAL_BUILD=1")

-    result.append('CMAKE_FLAGS="' + ' '.join(cmake_flags) + '"')
+    result.append('CMAKE_FLAGS="' + " ".join(cmake_flags) + '"')

    return result

+
 if __name__ == "__main__":
-    logging.basicConfig(level=logging.INFO, format='%(asctime)s %(message)s')
-    parser = argparse.ArgumentParser(description="ClickHouse building script using prebuilt Docker image")
-    # 'performance' creates a combined .tgz with server and configs to be used for performance test.
-    parser.add_argument("--package-type", choices=['deb', 'binary', 'performance'], required=True)
-    parser.add_argument("--clickhouse-repo-path", default=os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir))
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        description="ClickHouse building script using prebuilt Docker image",
+    )
+    # 'performance' creates a combined .tgz with server
+    # and configs to be used for performance test.
+    parser.add_argument(
+        "--package-type",
+        choices=("deb", "binary", "performance"),
+        required=True,
+        help="a build type",
+    )
+    parser.add_argument(
+        "--clickhouse-repo-path",
+        default=os.path.join(
+            os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir
+        ),
+        help="ClickHouse git repository",
+    )
    parser.add_argument("--output-dir", required=True)
    parser.add_argument("--build-type", choices=("debug", ""), default="")
-    parser.add_argument("--compiler", choices=("clang-11", "clang-11-darwin", "clang-11-darwin-aarch64", "clang-11-aarch64",
-                                               "clang-12", "clang-12-darwin", "clang-12-darwin-aarch64", "clang-12-aarch64",
-                                               "clang-13", "clang-13-darwin", "clang-13-darwin-aarch64", "clang-13-aarch64", "clang-13-ppc64le",
-                                               "clang-11-freebsd", "clang-12-freebsd", "clang-13-freebsd", "gcc-11"), default="clang-13")
-    parser.add_argument("--sanitizer", choices=("address", "thread", "memory", "undefined", ""), default="")
+    parser.add_argument(
+        "--compiler",
+        choices=(
+            "clang-11",
+            "clang-11-darwin",
+            "clang-11-darwin-aarch64",
+            "clang-11-aarch64",
+            "clang-12",
+            "clang-12-darwin",
+            "clang-12-darwin-aarch64",
+            "clang-12-aarch64",
+            "clang-13",
+            "clang-13-darwin",
+            "clang-13-darwin-aarch64",
+            "clang-13-aarch64",
+            "clang-13-ppc64le",
+            "clang-11-freebsd",
+            "clang-12-freebsd",
+            "clang-13-freebsd",
+            "gcc-11",
+        ),
+        default="clang-13",
+        help="a compiler to use",
+    )
+    parser.add_argument(
+        "--sanitizer",
+        choices=("address", "thread", "memory", "undefined", ""),
+        default="",
+    )
    parser.add_argument("--split-binary", action="store_true")
    parser.add_argument("--clang-tidy", action="store_true")
-    parser.add_argument("--cache", choices=("", "ccache", "distcc"), default="")
-    parser.add_argument("--ccache_dir", default= os.getenv("HOME", "") + '/.ccache')
+    parser.add_argument("--cache", choices=("ccache", "distcc", ""), default="")
+    parser.add_argument(
+        "--ccache_dir",
+        default=os.getenv("HOME", "") + "/.ccache",
+        help="a directory with ccache",
+    )
    parser.add_argument("--distcc-hosts", nargs="+")
    parser.add_argument("--force-build-image", action="store_true")
    parser.add_argument("--version")
-    parser.add_argument("--author", default="clickhouse")
+    parser.add_argument("--author", default="clickhouse", help="a package author")
    parser.add_argument("--official", action="store_true")
-    parser.add_argument("--alien-pkgs", nargs='+', default=[])
+    parser.add_argument("--additional-pkgs", action="store_true")
    parser.add_argument("--with-coverage", action="store_true")
-    parser.add_argument("--with-binaries", choices=("programs", "tests", ""), default="")
-    parser.add_argument("--docker-image-version", default="latest")
+    parser.add_argument(
+        "--with-binaries", choices=("programs", "tests", ""), default=""
+    )
+    parser.add_argument(
+        "--docker-image-version", default="latest", help="docker image tag to use"
+    )

    args = parser.parse_args()
    if not os.path.isabs(args.output_dir):
        args.output_dir = os.path.abspath(os.path.join(os.getcwd(), args.output_dir))

-    image_type = 'binary' if args.package_type == 'performance' else args.package_type
-    image_name = IMAGE_MAP[image_type]
+    image_type = "binary" if args.package_type == "performance" else args.package_type
+    image_name = "clickhouse/binary-builder"

    if not os.path.isabs(args.clickhouse_repo_path):
        ch_root = os.path.abspath(os.path.join(os.getcwd(), args.clickhouse_repo_path))
    else:
        ch_root = args.clickhouse_repo_path

-    if args.alien_pkgs and not image_type == "deb":
-        raise Exception("Can add alien packages only in deb build")
+    if args.additional_pkgs and image_type != "deb":
+        raise Exception("Can build additional packages only in deb build")

-    if args.with_binaries != "" and not image_type == "deb":
+    if args.with_binaries != "" and image_type != "deb":
        raise Exception("Can add additional binaries only in deb build")

    if args.with_binaries != "" and image_type == "deb":
-        logging.info("Should place {} to output".format(args.with_binaries))
+        logging.info("Should place %s to output", args.with_binaries)

    dockerfile = os.path.join(ch_root, "docker/packager", image_type, "Dockerfile")
    image_with_version = image_name + ":" + args.docker_image_version
-    if image_type != "freebsd" and not check_image_exists_locally(image_name) or args.force_build_image:
+    if (
+        image_type != "freebsd"
+        and not check_image_exists_locally(image_name)
+        or args.force_build_image
+    ):
        if not pull_image(image_with_version) or args.force_build_image:
            build_image(image_with_version, dockerfile)
    env_prepared = parse_env_variables(
-        args.build_type, args.compiler, args.sanitizer, args.package_type, image_type,
-        args.cache, args.distcc_hosts, args.split_binary, args.clang_tidy,
-        args.version, args.author, args.official, args.alien_pkgs, args.with_coverage, args.with_binaries)
+        args.build_type,
+        args.compiler,
+        args.sanitizer,
+        args.package_type,
+        image_type,
+        args.cache,
+        args.distcc_hosts,
+        args.split_binary,
+        args.clang_tidy,
+        args.version,
+        args.author,
+        args.official,
+        args.additional_pkgs,
+        args.with_coverage,
+        args.with_binaries,
+    )

-    run_docker_image_with_env(image_name, args.output_dir, env_prepared, ch_root, args.ccache_dir, args.docker_image_version)
-    logging.info("Output placed into {}".format(args.output_dir))
+    run_docker_image_with_env(
+        image_name,
+        args.output_dir,
+        env_prepared,
+        ch_root,
+        args.ccache_dir,
+        args.docker_image_version,
+    )
+    logging.info("Output placed into %s", args.output_dir)
--- a/docker/test/style/run.sh
+++ b/docker/test/style/run.sh
@ -11,7 +11,7 @@ echo "Check typos" | ts
 ./check-typos                 |& tee /test_output/typos_output.txt
 echo "Check whitespaces" | ts
 ./check-whitespaces -n        |& tee /test_output/whitespaces_output.txt
-echo "Check sorkflows" | ts
+echo "Check workflows" | ts
 ./check-workflows             |& tee /test_output/workflows_output.txt
 echo "Check shell scripts with shellcheck" | ts
 ./shellcheck-run.sh           |& tee /test_output/shellcheck_output.txt
--- a/packages/.gitignore
+++ b/packages/.gitignore
@ -0,0 +1 @@
+*/
--- a/packages/build
+++ b/packages/build
@ -0,0 +1,156 @@
+#!/usr/bin/env bash
+
+set -e
+
+# Avoid dependency on locale
+LC_ALL=C
+
+# Normalize output directory
+if [ -n "$OUTPUT_DIR" ]; then
+    OUTPUT_DIR=$(realpath -m "$OUTPUT_DIR")
+fi
+
+CUR_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+cd "$CUR_DIR"
+
+ROOT_DIR=$(readlink -f "$(git rev-parse --show-cdup)")
+
+PKG_ROOT='root'
+
+DEB_ARCH=${DEB_ARCH:-amd64}
+OUTPUT_DIR=${OUTPUT_DIR:-$ROOT_DIR}
+[ -d "${OUTPUT_DIR}" ] || mkdir -p "${OUTPUT_DIR}"
+SANITIZER=${SANITIZER:-""}
+SOURCE=${SOURCE:-$PKG_ROOT}
+
+HELP="${0} [--test] [--rpm] [-h|--help]
+  --test - adds '+test' prefix to version
+  --apk - build APK packages
+  --rpm - build RPM packages
+  --tgz - build tarball package
+  --help - show this help and exit
+
+Used envs:
+  DEB_ARCH='${DEB_ARCH}'
+  OUTPUT_DIR='${OUTPUT_DIR}' - where the artifact will be placed
+  SANITIZER='${SANITIZER}' - if any sanitizer is used, affects version string
+  SOURCE='${SOURCE}' - directory with sources tree
+  VERSION_STRING='${VERSION_STRING}' - the package version to overwrite
+"
+
+if [ -z "${VERSION_STRING}" ]; then
+    # Get CLICKHOUSE_VERSION_STRING from the current git repo
+    eval "$("$ROOT_DIR/tests/ci/version_helper.py" -e)"
+else
+    CLICKHOUSE_VERSION_STRING=${VERSION_STRING}
+fi
+export CLICKHOUSE_VERSION_STRING
+
+
+
+while [[ $1 == --* ]]
+do
+    case "$1" in
+        --test )
+            VERSION_POSTFIX+='+test'
+            shift ;;
+        --apk )
+            MAKE_APK=1
+            shift ;;
+        --rpm )
+            MAKE_RPM=1
+            shift ;;
+        --tgz )
+            MAKE_TGZ=1
+            shift ;;
+        --help )
+            echo "$HELP"
+            exit ;;
+        * )
+            echo "Unknown option $1"
+            exit 2 ;;
+    esac
+done
+
+function deb2tgz {
+    local FILE PKG_NAME PKG_DIR PKG_PATH TARBALL
+    FILE=$1
+    PKG_NAME=${FILE##*/}; PKG_NAME=${PKG_NAME%%_*}
+    PKG_DIR="$PKG_NAME-$CLICKHOUSE_VERSION_STRING"
+    PKG_PATH="$OUTPUT_DIR/$PKG_NAME-$CLICKHOUSE_VERSION_STRING"
+    TARBALL="$OUTPUT_DIR/$PKG_NAME-$CLICKHOUSE_VERSION_STRING-$DEB_ARCH.tgz"
+    rm -rf "$PKG_PATH"
+    dpkg-deb -R "$FILE" "$PKG_PATH"
+    mkdir -p "$PKG_PATH/install"
+    cat > "$PKG_PATH/install/doinst.sh" << 'EOF'
+#!/bin/sh
+set -e
+
+SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
+for filepath in `find $SCRIPTPATH/.. -type f -or -type l | grep -v "\.\./install/"`; do
+    destpath=${filepath##$SCRIPTPATH/..}
+    mkdir -p $(dirname "$destpath")
+    cp -r "$filepath" "$destpath"
+done
+EOF
+    chmod +x "$PKG_PATH/install/doinst.sh"
+    if [ -f "$PKG_PATH/DEBIAN/postinst" ]; then
+        tail +2 "$PKG_PATH/DEBIAN/postinst" > "$PKG_PATH/install/doinst.sh"
+    fi
+    rm -rf "$PKG_PATH/DEBIAN"
+    if [ -f "/usr/bin/pigz" ]; then
+        tar --use-compress-program=pigz -cf "$TARBALL" -C "$OUTPUT_DIR" "$PKG_DIR"
+    else
+        tar -czf "$TARBALL" -C "$OUTPUT_DIR" "$PKG_DIR"
+    fi
+
+    rm -r "$PKG_PATH"
+}
+
+# Build options
+if [ -n "$SANITIZER" ]; then
+    if [[ "$SANITIZER" == "address" ]]; then VERSION_POSTFIX+="+asan"
+    elif [[ "$SANITIZER" == "thread" ]]; then VERSION_POSTFIX+="+tsan"
+    elif [[ "$SANITIZER" == "memory" ]]; then VERSION_POSTFIX+="+msan"
+    elif [[ "$SANITIZER" == "undefined" ]]; then VERSION_POSTFIX+="+ubsan"
+    else
+        echo "Unknown value of SANITIZER variable: $SANITIZER"
+        exit 3
+    fi
+elif [[ $BUILD_TYPE == 'debug' ]]; then
+    VERSION_POSTFIX+="+debug"
+fi
+
+if [[ "$PKG_ROOT" != "$SOURCE" ]]; then
+    # packages are built only from PKG_SOURCE
+    rm -rf "./$PKG_ROOT"
+    ln -sf "$SOURCE" "$PKG_SOURCE"
+fi
+
+CLICKHOUSE_VERSION_STRING+=$VERSION_POSTFIX
+echo -e "\nCurrent version is $CLICKHOUSE_VERSION_STRING"
+
+for config in clickhouse*.yaml; do
+    echo "Building deb package for $config"
+
+    # Preserve package path
+    exec 9>&1
+    PKG_PATH=$(nfpm package --target "$OUTPUT_DIR" --config "$config" --packager deb | tee /dev/fd/9)
+    PKG_PATH=${PKG_PATH##*created package: }
+    exec 9>&-
+
+    if [ -n "$MAKE_APK" ]; then
+      echo "Building apk package for $config"
+      nfpm package --target "$OUTPUT_DIR" --config "$config" --packager apk
+    fi
+    if [ -n "$MAKE_RPM" ]; then
+      echo "Building rpm package for $config"
+      nfpm package --target "$OUTPUT_DIR" --config "$config" --packager rpm
+    fi
+    if [ -n "$MAKE_TGZ" ]; then
+      echo "Building tarball for $config"
+      deb2tgz "$PKG_PATH"
+    fi
+done
+
+# vim: ts=4: sw=4: sts=4: expandtab
--- a/packages/clickhouse-client.yaml
+++ b/packages/clickhouse-client.yaml
@ -0,0 +1,57 @@
+# package sources should be placed in ${PWD}/root
+# nfpm should run from the same directory with a config
+name: "clickhouse-client"
+arch: "all"
+platform: "linux"
+version: "${CLICKHOUSE_VERSION_STRING}"
+vendor: "ClickHouse Inc."
+homepage: "https://clickhouse.com"
+license: "Apache"
+section: "database"
+priority: "optional"
+
+replaces:
+- clickhouse-compressor
+conflicts:
+- clickhouse-compressor
+
+maintainer: "ClickHouse Dev Team <packages+linux@clickhouse.com>"
+description: |
+  Client binary for ClickHouse
+    ClickHouse is a column-oriented database management system
+    that allows generating analytical data reports in real time.
+    This package provides clickhouse-client , clickhouse-local and clickhouse-benchmark
+
+overrides:
+  deb:
+    depends:
+    - clickhouse-common-static (= ${CLICKHOUSE_VERSION_STRING})
+  rpm:
+    depends:
+    - clickhouse-common-static = ${CLICKHOUSE_VERSION_STRING}
+
+contents:
+- src: root/etc/clickhouse-client/config.xml
+  dst: /etc/clickhouse-client/config.xml
+  type: config
+- src: root/usr/bin/clickhouse-benchmark
+  dst: /usr/bin/clickhouse-benchmark
+- src: root/usr/bin/clickhouse-compressor
+  dst: /usr/bin/clickhouse-compressor
+- src: root/usr/bin/clickhouse-format
+  dst: /usr/bin/clickhouse-format
+- src: root/usr/bin/clickhouse-client
+  dst: /usr/bin/clickhouse-client
+- src: root/usr/bin/clickhouse-local
+  dst: /usr/bin/clickhouse-local
+- src: root/usr/bin/clickhouse-obfuscator
+  dst: /usr/bin/clickhouse-obfuscator
+# docs
+- src: ../AUTHORS
+  dst: /usr/share/doc/clickhouse-client/AUTHORS
+- src: ../CHANGELOG.md
+  dst: /usr/share/doc/clickhouse-client/CHANGELOG.md
+- src: ../LICENSE
+  dst: /usr/share/doc/clickhouse-client/LICENSE
+- src: ../README.md
+  dst: /usr/share/doc/clickhouse-client/README.md
--- a/packages/clickhouse-common-static-dbg.yaml
+++ b/packages/clickhouse-common-static-dbg.yaml
@ -0,0 +1,34 @@
+# package sources should be placed in ${PWD}/root
+# nfpm should run from the same directory with a config
+name: "clickhouse-common-static-dbg"
+arch: "${DEB_ARCH}" # amd64, arm64
+platform: "linux"
+version: "${CLICKHOUSE_VERSION_STRING}"
+vendor: "ClickHouse Inc."
+homepage: "https://clickhouse.com"
+license: "Apache"
+section: "database"
+priority: "optional"
+
+replaces:
+- clickhouse-common-dbg
+conflicts:
+- clickhouse-common-dbg
+
+maintainer: "ClickHouse Dev Team <packages+linux@clickhouse.com>"
+description: |
+  debugging symbols for clickhouse-common-static
+    This package contains the debugging symbols for clickhouse-common.
+
+contents:
+- src: root/usr/lib/debug
+  dst: /usr/lib/debug
+# docs
+- src: ../AUTHORS
+  dst: /usr/share/doc/clickhouse-common-static-dbg/AUTHORS
+- src: ../CHANGELOG.md
+  dst: /usr/share/doc/clickhouse-common-static-dbg/CHANGELOG.md
+- src: ../LICENSE
+  dst: /usr/share/doc/clickhouse-common-static-dbg/LICENSE
+- src: ../README.md
+  dst: /usr/share/doc/clickhouse-common-static-dbg/README.md
--- a/packages/clickhouse-common-static.yaml
+++ b/packages/clickhouse-common-static.yaml
@ -0,0 +1,48 @@
+# package sources should be placed in ${PWD}/root
+# nfpm should run from the same directory with a config
+name: "clickhouse-common-static"
+arch: "${DEB_ARCH}" # amd64, arm64
+platform: "linux"
+version: "${CLICKHOUSE_VERSION_STRING}"
+vendor: "ClickHouse Inc."
+homepage: "https://clickhouse.com"
+license: "Apache"
+section: "database"
+priority: "optional"
+
+replaces:
+- clickhouse-common
+- clickhouse-server-base
+provides:
+- clickhouse-common
+- clickhouse-server-base
+suggests:
+- clickhouse-common-static-dbg
+
+maintainer: "ClickHouse Dev Team <packages+linux@clickhouse.com>"
+description: |
+  Common files for ClickHouse
+    ClickHouse is a column-oriented database management system
+    that allows generating analytical data reports in real time.
+    This package provides common files for both clickhouse server and client
+
+contents:
+- src: root/usr/bin/clickhouse
+  dst: /usr/bin/clickhouse
+- src: root/usr/bin/clickhouse-odbc-bridge
+  dst: /usr/bin/clickhouse-odbc-bridge
+- src: root/usr/bin/clickhouse-library-bridge
+  dst: /usr/bin/clickhouse-library-bridge
+- src: root/usr/bin/clickhouse-extract-from-config
+  dst: /usr/bin/clickhouse-extract-from-config
+- src: root/usr/share/bash-completion/completions
+  dst: /usr/share/bash-completion/completions
+# docs
+- src: ../AUTHORS
+  dst: /usr/share/doc/clickhouse-common-static/AUTHORS
+- src: ../CHANGELOG.md
+  dst: /usr/share/doc/clickhouse-common-static/CHANGELOG.md
+- src: ../LICENSE
+  dst: /usr/share/doc/clickhouse-common-static/LICENSE
+- src: ../README.md
+  dst: /usr/share/doc/clickhouse-common-static/README.md
--- a/packages/clickhouse-server.init
+++ b/packages/clickhouse-server.init
@ -0,0 +1,227 @@
+#!/bin/sh
+### BEGIN INIT INFO
+# Provides:          clickhouse-server
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# Should-Start:      $time $network
+# Should-Stop:       $network
+# Short-Description: clickhouse-server daemon
+### END INIT INFO
+#
+# NOTES:
+# - Should-* -- script can start if the listed facilities are missing, unlike Required-*
+#
+# For the documentation [1]:
+#
+#   [1]: https://wiki.debian.org/LSBInitScripts
+
+CLICKHOUSE_USER=clickhouse
+CLICKHOUSE_GROUP=${CLICKHOUSE_USER}
+SHELL=/bin/bash
+PROGRAM=clickhouse-server
+CLICKHOUSE_GENERIC_PROGRAM=clickhouse
+CLICKHOUSE_PROGRAM_ENV=""
+EXTRACT_FROM_CONFIG=${CLICKHOUSE_GENERIC_PROGRAM}-extract-from-config
+CLICKHOUSE_CONFDIR=/etc/$PROGRAM
+CLICKHOUSE_LOGDIR=/var/log/clickhouse-server
+CLICKHOUSE_LOGDIR_USER=root
+CLICKHOUSE_DATADIR=/var/lib/clickhouse
+if [ -d "/var/lock" ]; then
+    LOCALSTATEDIR=/var/lock
+else
+    LOCALSTATEDIR=/run/lock
+fi
+
+if [ ! -d "$LOCALSTATEDIR" ]; then
+    mkdir -p "$LOCALSTATEDIR"
+fi
+
+CLICKHOUSE_BINDIR=/usr/bin
+CLICKHOUSE_CRONFILE=/etc/cron.d/clickhouse-server
+CLICKHOUSE_CONFIG=$CLICKHOUSE_CONFDIR/config.xml
+LOCKFILE=$LOCALSTATEDIR/$PROGRAM
+CLICKHOUSE_PIDDIR=/var/run/$PROGRAM
+CLICKHOUSE_PIDFILE="$CLICKHOUSE_PIDDIR/$PROGRAM.pid"
+# CLICKHOUSE_STOP_TIMEOUT=60 # Disabled by default. Place to /etc/default/clickhouse if you need.
+
+# Some systems lack "flock"
+command -v flock >/dev/null && FLOCK=flock
+
+# Override defaults from optional config file
+test -f /etc/default/clickhouse && . /etc/default/clickhouse
+
+
+die()
+{
+    echo $1 >&2
+    exit 1
+}
+
+
+# Check that configuration file is Ok.
+check_config()
+{
+    if [ -x "$CLICKHOUSE_BINDIR/$EXTRACT_FROM_CONFIG" ]; then
+        su -s $SHELL ${CLICKHOUSE_USER} -c "$CLICKHOUSE_BINDIR/$EXTRACT_FROM_CONFIG --config-file=\"$CLICKHOUSE_CONFIG\" --key=path" >/dev/null || die "Configuration file ${CLICKHOUSE_CONFIG} doesn't parse successfully. Won't restart server. You may use forcerestart if you are sure.";
+    fi
+}
+
+
+initdb()
+{
+    ${CLICKHOUSE_GENERIC_PROGRAM} install --user "${CLICKHOUSE_USER}" --pid-path "${CLICKHOUSE_PIDDIR}" --config-path "${CLICKHOUSE_CONFDIR}" --binary-path "${CLICKHOUSE_BINDIR}"
+}
+
+
+start()
+{
+    ${CLICKHOUSE_GENERIC_PROGRAM} start --user "${CLICKHOUSE_USER}" --pid-path "${CLICKHOUSE_PIDDIR}" --config-path "${CLICKHOUSE_CONFDIR}" --binary-path "${CLICKHOUSE_BINDIR}"
+}
+
+
+stop()
+{
+    ${CLICKHOUSE_GENERIC_PROGRAM} stop --pid-path "${CLICKHOUSE_PIDDIR}"
+}
+
+
+restart()
+{
+    ${CLICKHOUSE_GENERIC_PROGRAM} restart --user "${CLICKHOUSE_USER}" --pid-path "${CLICKHOUSE_PIDDIR}" --config-path "${CLICKHOUSE_CONFDIR}" --binary-path "${CLICKHOUSE_BINDIR}"
+}
+
+
+forcestop()
+{
+    ${CLICKHOUSE_GENERIC_PROGRAM} stop --force --pid-path "${CLICKHOUSE_PIDDIR}"
+}
+
+
+service_or_func()
+{
+    if [ -x "/bin/systemctl" ] && [ -f /etc/systemd/system/clickhouse-server.service ] && [ -d /run/systemd/system ]; then
+        systemctl $1 $PROGRAM
+    else
+        $1
+    fi
+}
+
+forcerestart()
+{
+    forcestop
+    # Should not use 'start' function if systemd active
+    service_or_func start
+}
+
+use_cron()
+{
+    # 1. running systemd
+    if [ -x "/bin/systemctl" ] && [ -f /etc/systemd/system/clickhouse-server.service ] && [ -d /run/systemd/system ]; then
+        return 1
+    fi
+    # 2. disabled by config
+    if [ -z "$CLICKHOUSE_CRONFILE" ]; then
+        return 2
+    fi
+    return 0
+}
+# returns false if cron disabled (with systemd)
+enable_cron()
+{
+    use_cron && sed -i 's/^#*//' "$CLICKHOUSE_CRONFILE"
+}
+# returns false if cron disabled (with systemd)
+disable_cron()
+{
+    use_cron && sed -i 's/^#*/#/' "$CLICKHOUSE_CRONFILE"
+}
+
+
+is_cron_disabled()
+{
+    use_cron || return 0
+
+    # Assumes that either no lines are commented or all lines are commented.
+    # Also please note, that currently cron file for ClickHouse has only one line (but some time ago there was more).
+    grep -q -E '^#' "$CLICKHOUSE_CRONFILE";
+}
+
+
+main()
+{
+    # See how we were called.
+    EXIT_STATUS=0
+    case "$1" in
+    start)
+        service_or_func start && enable_cron
+        ;;
+    stop)
+        disable_cron
+        service_or_func stop
+        ;;
+    restart)
+        service_or_func restart && enable_cron
+        ;;
+    forcestop)
+        disable_cron
+        forcestop
+        ;;
+    forcerestart)
+        forcerestart && enable_cron
+        ;;
+    reload)
+        service_or_func restart
+        ;;
+    condstart)
+        service_or_func start
+        ;;
+    condstop)
+        service_or_func stop
+        ;;
+    condrestart)
+        service_or_func restart
+        ;;
+    condreload)
+        service_or_func restart
+        ;;
+    initdb)
+        initdb
+        ;;
+    enable_cron)
+        enable_cron
+        ;;
+    disable_cron)
+        disable_cron
+        ;;
+    *)
+        echo "Usage: $0 {start|stop|status|restart|forcestop|forcerestart|reload|condstart|condstop|condrestart|condreload|initdb}"
+        exit 2
+        ;;
+    esac
+
+    exit $EXIT_STATUS
+}
+
+
+status()
+{
+    ${CLICKHOUSE_GENERIC_PROGRAM} status --pid-path "${CLICKHOUSE_PIDDIR}"
+}
+
+
+# Running commands without need of locking
+case "$1" in
+status)
+    status
+    exit 0
+    ;;
+esac
+
+
+(
+    if $FLOCK -n 9; then
+        main "$@"
+    else
+        echo "Init script is already running" && exit 1
+    fi
+) 9> $LOCKFILE
--- a/packages/clickhouse-server.postinstall
+++ b/packages/clickhouse-server.postinstall
@ -0,0 +1,47 @@
+#!/bin/sh
+set -e
+# set -x
+
+PROGRAM=clickhouse-server
+CLICKHOUSE_USER=${CLICKHOUSE_USER:=clickhouse}
+CLICKHOUSE_GROUP=${CLICKHOUSE_GROUP:=${CLICKHOUSE_USER}}
+# Please note that we don't support paths with whitespaces. This is rather ignorant.
+CLICKHOUSE_CONFDIR=${CLICKHOUSE_CONFDIR:=/etc/clickhouse-server}
+CLICKHOUSE_DATADIR=${CLICKHOUSE_DATADIR:=/var/lib/clickhouse}
+CLICKHOUSE_LOGDIR=${CLICKHOUSE_LOGDIR:=/var/log/clickhouse-server}
+CLICKHOUSE_BINDIR=${CLICKHOUSE_BINDIR:=/usr/bin}
+CLICKHOUSE_GENERIC_PROGRAM=${CLICKHOUSE_GENERIC_PROGRAM:=clickhouse}
+EXTRACT_FROM_CONFIG=${CLICKHOUSE_GENERIC_PROGRAM}-extract-from-config
+CLICKHOUSE_CONFIG=$CLICKHOUSE_CONFDIR/config.xml
+CLICKHOUSE_PIDDIR=/var/run/$PROGRAM
+
+[ -f /usr/share/debconf/confmodule ] && . /usr/share/debconf/confmodule
+[ -f /etc/default/clickhouse ] && . /etc/default/clickhouse
+
+if [ ! -f "/etc/debian_version" ]; then
+    not_deb_os=1
+fi
+
+if [ "$1" = configure ] || [ -n "$not_deb_os" ]; then
+
+    ${CLICKHOUSE_GENERIC_PROGRAM} install --user "${CLICKHOUSE_USER}" --group "${CLICKHOUSE_GROUP}" --pid-path "${CLICKHOUSE_PIDDIR}" --config-path "${CLICKHOUSE_CONFDIR}" --binary-path "${CLICKHOUSE_BINDIR}" --log-path "${CLICKHOUSE_LOGDIR}" --data-path "${CLICKHOUSE_DATADIR}"
+
+    if [ -x "/bin/systemctl" ] && [ -f /etc/systemd/system/clickhouse-server.service ] && [ -d /run/systemd/system ]; then
+        # if old rc.d service present - remove it
+        if [ -x "/etc/init.d/clickhouse-server" ] && [ -x "/usr/sbin/update-rc.d" ]; then
+            /usr/sbin/update-rc.d clickhouse-server remove
+        fi
+
+        /bin/systemctl daemon-reload
+        /bin/systemctl enable clickhouse-server
+    else
+        # If you downgrading to version older than 1.1.54336 run: systemctl disable clickhouse-server
+        if [ -x "/etc/init.d/clickhouse-server" ]; then
+            if [ -x "/usr/sbin/update-rc.d" ]; then
+                /usr/sbin/update-rc.d clickhouse-server defaults 19 19 >/dev/null || exit $?
+            else
+                echo # Other OS
+            fi
+        fi
+    fi
+fi
--- a/packages/clickhouse-server.service
+++ b/packages/clickhouse-server.service
@ -0,0 +1,27 @@
+[Unit]
+Description=ClickHouse Server (analytic DBMS for big data)
+Requires=network-online.target
+# NOTE: that After/Wants=time-sync.target is not enough, you need to ensure
+# that the time was adjusted already, if you use systemd-timesyncd you are
+# safe, but if you use ntp or some other daemon, you should configure it
+# additionaly.
+After=time-sync.target network-online.target
+Wants=time-sync.target
+
+[Service]
+Type=simple
+User=clickhouse
+Group=clickhouse
+Restart=always
+RestartSec=30
+RuntimeDirectory=clickhouse-server
+ExecStart=/usr/bin/clickhouse-server --config=/etc/clickhouse-server/config.xml --pid-file=/run/clickhouse-server/clickhouse-server.pid
+# Minus means that this file is optional.
+EnvironmentFile=-/etc/default/clickhouse
+LimitCORE=infinity
+LimitNOFILE=500000
+CapabilityBoundingSet=CAP_NET_ADMIN CAP_IPC_LOCK CAP_SYS_NICE
+
+[Install]
+# ClickHouse should not start from the rescue shell (rescue.target).
+WantedBy=multi-user.target
--- a/packages/clickhouse-server.yaml
+++ b/packages/clickhouse-server.yaml
@ -0,0 +1,68 @@
+# package sources should be placed in ${PWD}/root
+# nfpm should run from the same directory with a config
+name: "clickhouse-server"
+arch: "all"
+platform: "linux"
+version: "${CLICKHOUSE_VERSION_STRING}"
+vendor: "ClickHouse Inc."
+homepage: "https://clickhouse.com"
+license: "Apache"
+section: "database"
+priority: "optional"
+
+conflicts:
+- clickhouse-keeper
+depends:
+- adduser
+replaces:
+- clickhouse-server-common
+- clickhouse-server-base
+provides:
+- clickhouse-server-common
+recommends:
+- libcap2-bin
+
+maintainer: "ClickHouse Dev Team <packages+linux@clickhouse.com>"
+description: |
+  Server binary for ClickHouse
+    ClickHouse is a column-oriented database management system
+    that allows generating analytical data reports in real time.
+    This package provides clickhouse common configuration files
+
+overrides:
+  deb:
+    depends:
+    - clickhouse-common-static (= ${CLICKHOUSE_VERSION_STRING})
+  rpm:
+    depends:
+    - clickhouse-common-static = ${CLICKHOUSE_VERSION_STRING}
+
+contents:
+- src: root/etc/clickhouse-server
+  dst: /etc/clickhouse-server
+  type: config
+- src: clickhouse-server.init
+  dst: /etc/init.d/clickhouse-server
+- src: clickhouse-server.service
+  dst: /lib/systemd/system/clickhouse-server.service
+- src: root/usr/bin/clickhouse-copier
+  dst: /usr/bin/clickhouse-copier
+- src: clickhouse
+  dst: /usr/bin/clickhouse-keeper
+  type: symlink
+- src: root/usr/bin/clickhouse-report
+  dst: /usr/bin/clickhouse-report
+- src: root/usr/bin/clickhouse-server
+  dst: /usr/bin/clickhouse-server
+# docs
+- src: ../AUTHORS
+  dst: /usr/share/doc/clickhouse-server/AUTHORS
+- src: ../CHANGELOG.md
+  dst: /usr/share/doc/clickhouse-server/CHANGELOG.md
+- src: ../LICENSE
+  dst: /usr/share/doc/clickhouse-server/LICENSE
+- src: ../README.md
+  dst: /usr/share/doc/clickhouse-server/README.md
+
+scripts:
+  postinstall: ./clickhouse-server.postinstall
--- a/programs/CMakeLists.txt
+++ b/programs/CMakeLists.txt
@ -460,10 +460,6 @@ else ()
        list(APPEND CLICKHOUSE_BUNDLE clickhouse-keeper-converter)
    endif ()

-    if (NOT BUILD_STRIPPED_BINARIES_PREFIX)
-        install (TARGETS clickhouse RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
-    endif()
-
    add_custom_target (clickhouse-bundle ALL DEPENDS ${CLICKHOUSE_BUNDLE})

    if (USE_GDB_ADD_INDEX)
@ -474,11 +470,19 @@ else ()
        add_custom_command(TARGET clickhouse POST_BUILD COMMAND ./clickhouse hash-binary > hash && ${OBJCOPY_PATH} --add-section .note.ClickHouse.hash=hash clickhouse COMMENT "Adding .note.ClickHouse.hash to clickhouse" VERBATIM)
    endif()

-    if (BUILD_STRIPPED_BINARIES_PREFIX)
-        clickhouse_strip_binary(TARGET clickhouse DESTINATION_DIR ${CMAKE_CURRENT_BINARY_DIR}/${BUILD_STRIPPED_BINARIES_PREFIX} BINARY_PATH clickhouse)
+    if (INSTALL_STRIPPED_BINARIES)
+        clickhouse_strip_binary(TARGET clickhouse DESTINATION_DIR ${CMAKE_CURRENT_BINARY_DIR}/${STRIPPED_BINARIES_OUTPUT} BINARY_PATH clickhouse)
+    else()
+        install (TARGETS clickhouse RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
    endif()
 endif()

+if (NOT INSTALL_STRIPPED_BINARIES)
+    # Install dunny debug directory
+    # TODO: move logic to every place where clickhouse_strip_binary is used
+    add_custom_command(TARGET clickhouse POST_BUILD COMMAND echo > .empty )
+    install(FILES "${CMAKE_CURRENT_BINARY_DIR}/.empty" DESTINATION ${CMAKE_INSTALL_LIBDIR}/debug/.empty)
+endif()


 if (ENABLE_TESTS)
--- a/programs/library-bridge/CMakeLists.txt
+++ b/programs/library-bridge/CMakeLists.txt
@ -24,10 +24,8 @@ target_link_libraries(clickhouse-library-bridge PRIVATE

 set_target_properties(clickhouse-library-bridge PROPERTIES RUNTIME_OUTPUT_DIRECTORY ..)

-if (BUILD_STRIPPED_BINARIES_PREFIX)
-    clickhouse_strip_binary(TARGET clickhouse-library-bridge DESTINATION_DIR ${CMAKE_CURRENT_BINARY_DIR}/../${BUILD_STRIPPED_BINARIES_PREFIX} BINARY_PATH ../clickhouse-library-bridge)
-endif()
-
-if (NOT BUILD_STRIPPED_BINARIES_PREFIX)
+if (INSTALL_STRIPPED_BINARIES)
+    clickhouse_strip_binary(TARGET clickhouse-library-bridge DESTINATION_DIR ${CMAKE_CURRENT_BINARY_DIR}/../${STRIPPED_BINARIES_OUTPUT} BINARY_PATH ../clickhouse-library-bridge)
+else()
    install(TARGETS clickhouse-library-bridge RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
 endif()
--- a/programs/odbc-bridge/CMakeLists.txt
+++ b/programs/odbc-bridge/CMakeLists.txt
@ -39,11 +39,9 @@ if (USE_GDB_ADD_INDEX)
    add_custom_command(TARGET clickhouse-odbc-bridge POST_BUILD COMMAND ${GDB_ADD_INDEX_EXE} ../clickhouse-odbc-bridge COMMENT "Adding .gdb-index to clickhouse-odbc-bridge" VERBATIM)
 endif()

-if (BUILD_STRIPPED_BINARIES_PREFIX)
-    clickhouse_strip_binary(TARGET clickhouse-odbc-bridge DESTINATION_DIR ${CMAKE_CURRENT_BINARY_DIR}/../${BUILD_STRIPPED_BINARIES_PREFIX} BINARY_PATH ../clickhouse-odbc-bridge)
-endif()
-
-if (NOT BUILD_STRIPPED_BINARIES_PREFIX)
+if (INSTALL_STRIPPED_BINARIES)
+    clickhouse_strip_binary(TARGET clickhouse-odbc-bridge DESTINATION_DIR ${CMAKE_CURRENT_BINARY_DIR}/../${STRIPPED_BINARIES_OUTPUT} BINARY_PATH ../clickhouse-odbc-bridge)
+else()
    install(TARGETS clickhouse-odbc-bridge RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
 endif()

--- a/src/Common/Dwarf.cpp
+++ b/src/Common/Dwarf.cpp
@ -25,7 +25,6 @@
 #include <Common/Dwarf.h>
 #include <Common/Exception.h>

-
 #define DW_CHILDREN_no 0
 #define DW_FORM_addr 1
 #define DW_FORM_block1 0x0a
@ -125,7 +124,7 @@ template <typename T>
 requires std::is_trivial_v<T> && std::is_standard_layout_v<T>
 T read(std::string_view & sp)
 {
-    SAFE_CHECK(sp.size() >= sizeof(T), "underflow");
+    SAFE_CHECK(sp.size() >= sizeof(T), fmt::format("underflow: expected bytes {}, got bytes {}", sizeof(T), sp.size()));
    T x;
    memcpy(&x, sp.data(), sizeof(T));
    sp.remove_prefix(sizeof(T));
@ -690,7 +689,7 @@ bool Dwarf::findDebugInfoOffset(uintptr_t address, std::string_view aranges, uin

 Dwarf::Die Dwarf::getDieAtOffset(const CompilationUnit & cu, uint64_t offset) const
 {
-    SAFE_CHECK(offset < info_.size(), "unexpected offset");
+    SAFE_CHECK(offset < info_.size(), fmt::format("unexpected offset {}, info size {}", offset, info_.size()));
    Die die;
    std::string_view sp{info_.data() + offset, cu.offset + cu.size - offset};
    die.offset = offset;
@ -708,19 +707,6 @@ Dwarf::Die Dwarf::getDieAtOffset(const CompilationUnit & cu, uint64_t offset) co
    return die;
 }

-Dwarf::Die Dwarf::findDefinitionDie(const CompilationUnit & cu, const Die & die) const
-{
-    // Find the real definition instead of declaration.
-    // DW_AT_specification: Incomplete, non-defining, or separate declaration
-    // corresponding to a declaration
-    auto offset = getAttribute<uint64_t>(cu, die, DW_AT_specification);
-    if (!offset)
-    {
-        return die;
-    }
-    return getDieAtOffset(cu, cu.offset + offset.value());
-}
-
 /**
 * Find the @locationInfo for @address in the compilation unit represented
 * by the @sp .debug_info entry.
@ -861,7 +847,10 @@ bool Dwarf::findLocation(
                    SymbolizedFrame inline_frame;
                    inline_frame.found = true;
                    inline_frame.addr = address;
-                    inline_frame.name = call_location.name.data();
+                    if (!call_location.name.empty())
+                        inline_frame.name = call_location.name.data();
+                    else
+                        inline_frame.name = nullptr;
                    inline_frame.location.has_file_and_line = true;
                    inline_frame.location.file = call_location.file;
                    inline_frame.location.line = call_location.line;
@ -1034,17 +1023,54 @@ void Dwarf::findInlinedSubroutineDieForAddress(
        location.file = line_vm.getFullFileName(*call_file);
        location.line = *call_line;

+        /// Something wrong with receiving debug info about inline.
+        /// If set to true we stop parsing DWARF.
+        bool die_for_inline_broken = false;
+
        auto get_function_name = [&](const CompilationUnit & srcu, uint64_t die_offset)
        {
-            auto decl_die = getDieAtOffset(srcu, die_offset);
+            Die decl_die = getDieAtOffset(srcu, die_offset);
+            auto & die_to_look_for_name = decl_die;
+
+            Die def_die;
            // Jump to the actual function definition instead of declaration for name
            // and line info.
-            auto def_die = findDefinitionDie(srcu, decl_die);
+            // DW_AT_specification: Incomplete, non-defining, or separate declaration
+            // corresponding to a declaration
+            auto offset = getAttribute<uint64_t>(srcu, decl_die, DW_AT_specification);
+            if (offset)
+            {
+                /// FIXME: actually it's a bug in our DWARF parser.
+                ///
+                /// Most of the times compilation unit offset (srcu.offset) is some big number inside .debug_info (like 434782255).
+                /// Offset of DIE definition is some small relative number to srcu.offset (like 3518).
+                /// However in some unknown cases offset looks like global, non relative number (like 434672579) and in this
+                /// case we obviously doing something wrong parsing DWARF.
+                ///
+                /// What is important -- this bug? reproduces only with -flto=thin in release mode.
+                /// Also llvm-dwarfdump --verify ./clickhouse says that our DWARF is ok, so it's another prove
+                /// that we just doing something wrong.
+                ///
+                /// FIXME: Currently we just give up parsing DWARF for inlines when we got into this situation.
+                if (srcu.offset + offset.value() >= info_.size())
+                {
+                    die_for_inline_broken = true;
+                }
+                else
+                {
+                    def_die = getDieAtOffset(srcu, srcu.offset + offset.value());
+                    die_to_look_for_name = def_die;
+                }
+            }

            std::string_view name;
+
+            if (die_for_inline_broken)
+                return name;
+
            // The file and line will be set in the next inline subroutine based on
            // its DW_AT_call_file and DW_AT_call_line.
-            forEachAttribute(srcu, def_die, [&](const Attribute & attr)
+            forEachAttribute(srcu, die_to_look_for_name, [&](const Attribute & attr)
            {
                switch (attr.spec.name)
                {
@ -1083,6 +1109,10 @@ void Dwarf::findInlinedSubroutineDieForAddress(
            ? get_function_name(cu, cu.offset + *abstract_origin)
            : get_function_name(findCompilationUnit(info_, *abstract_origin), *abstract_origin);

+        /// FIXME: see comment above
+        if (die_for_inline_broken)
+            return false;
+
        locations.push_back(location);

        findInlinedSubroutineDieForAddress(cu, child_die, line_vm, address, base_addr_cu, locations, max_size);
--- a/src/Common/Dwarf.h
+++ b/src/Common/Dwarf.h
@ -260,11 +260,6 @@ private:
    /** cu must exist during the life cycle of created detail::Die. */
    Die getDieAtOffset(const CompilationUnit & cu, uint64_t offset) const;

-    /**
-     * Find the actual definition DIE instead of declaration for the given die.
-     */
-    Die findDefinitionDie(const CompilationUnit & cu, const Die & die) const;
-
    bool findLocation(
        uintptr_t address,
        LocationInfoMode mode,
--- a/src/Functions/addressToLineWithInlines.cpp
+++ b/src/Functions/addressToLineWithInlines.cpp
@ -75,7 +75,7 @@ private:
        writeChar(':', out);
        writeIntText(location.line, out);

-        if (frame)
+        if (frame && frame->name != nullptr)
        {
            writeChar(':', out);
            int status = 0;
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@ -7,7 +7,7 @@ else ()
    include (${ClickHouse_SOURCE_DIR}/cmake/add_check.cmake)
 endif ()

-option (ENABLE_CLICKHOUSE_TEST "Install clickhouse-test script and relevant tests scenarios" ON)
+option (ENABLE_CLICKHOUSE_TEST "Install clickhouse-test script and relevant tests scenarios" OFF)

 if (ENABLE_CLICKHOUSE_TEST)
    install (PROGRAMS clickhouse-test DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
--- a/tests/ci/build_check.py
+++ b/tests/ci/build_check.py
@ -21,6 +21,8 @@ from ci_config import CI_CONFIG, BuildConfig
 from docker_pull_helper import get_image_with_version
 from tee_popen import TeePopen

+IMAGE_NAME = "clickhouse/binary-builder"
+

 def get_build_config(build_check_name: str, build_name: str) -> BuildConfig:
    if build_check_name == "ClickHouse build check (actions)":
@ -52,7 +54,6 @@ def get_packager_cmd(
    build_version: str,
    image_version: str,
    ccache_path: str,
-    pr_info: PRInfo,
 ) -> str:
    package_type = build_config["package_type"]
    comp = build_config["compiler"]
@ -73,9 +74,8 @@ def get_packager_cmd(
    cmd += " --cache=ccache"
    cmd += " --ccache_dir={}".format(ccache_path)

-    if "alien_pkgs" in build_config and build_config["alien_pkgs"]:
-        if pr_info.number == 0 or "release" in pr_info.labels:
-            cmd += " --alien-pkgs rpm tgz"
+    if "additional_pkgs" in build_config and build_config["additional_pkgs"]:
+        cmd += " --additional-pkgs"

    cmd += " --docker-image-version={}".format(image_version)
    cmd += " --version={}".format(build_version)
@ -86,13 +86,6 @@ def get_packager_cmd(
    return cmd


-def get_image_name(build_config: BuildConfig) -> str:
-    if build_config["package_type"] != "deb":
-        return "clickhouse/binary-builder"
-    else:
-        return "clickhouse/deb-builder"
-
-
 def build_clickhouse(
    packager_cmd: str, logs_path: str, build_output_path: str
 ) -> Tuple[str, bool]:
@ -256,8 +249,7 @@ def main():
        else:
            sys.exit(0)

-    image_name = get_image_name(build_config)
-    docker_image = get_image_with_version(IMAGES_PATH, image_name)
+    docker_image = get_image_with_version(IMAGES_PATH, IMAGE_NAME)
    image_version = docker_image.version

    logging.info("Got version from repo %s", version.string)
@ -298,7 +290,6 @@ def main():
        version.string,
        image_version,
        ccache_path,
-        pr_info,
    )
    logging.info("Going to run packager with %s", packager_cmd)

--- a/tests/ci/build_report_check.py
+++ b/tests/ci/build_report_check.py
@ -27,12 +27,14 @@ class BuildResult():
        self.with_coverage = with_coverage

 def group_by_artifacts(build_urls):
-    groups = {'deb': [], 'binary': [], 'tgz': [], 'rpm': [], 'performance': []}
+    groups = {'apk': [],'deb': [], 'binary': [], 'tgz': [], 'rpm': [], 'performance': []}
    for url in build_urls:
        if url.endswith('performance.tgz'):
            groups['performance'].append(url)
        elif url.endswith('.deb') or url.endswith('.buildinfo') or url.endswith('.changes') or url.endswith('.tar.gz'):
            groups['deb'].append(url)
+        elif url.endswith('.apk'):
+            groups['apk'].append(url)
        elif url.endswith('.rpm'):
            groups['rpm'].append(url)
        elif url.endswith('.tgz'):
--- a/tests/ci/ci_config.py
+++ b/tests/ci/ci_config.py
@ -14,7 +14,7 @@ CI_CONFIG = {
            "package_type": "deb",
            "bundled": "bundled",
            "splitted": "unsplitted",
-            "alien_pkgs": True,
+            "additional_pkgs": True,
            "tidy": "disable",
            "with_coverage": False,
        },
@ -45,7 +45,7 @@ CI_CONFIG = {
            "package_type": "deb",
            "bundled": "bundled",
            "splitted": "unsplitted",
-            "alien_pkgs": True,
+            "additional_pkgs": True,
            "tidy": "disable",
            "with_coverage": False,
        },