Adding DEB Maintainers Scripts and Build CI Images

docker/ci/dockerfiles/current/build.ubuntu2004.opensearch.x64.arm64.dockerfile

@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# The OpenSearch Contributors require contributions made to
+# this file be licensed under the Apache-2.0 license or a
+# compatible open source license.
+
+# This is a docker image specifically for assembling the DEB version of OpenSearch/OpenSearch-Dashboards
+# This is not capable of building k-NN plugin as it lacks the necessary old version of glibc on CentOS7
+
+FROM ubuntu:20.04
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+# Install python37 dependencies
+RUN apt-get update -y && apt-get install -y software-properties-common && add-apt-repository ppa:deadsnakes/ppa -y
+
+# Install python37 binaries
+RUN apt-get update -y && apt-get install python3 && \
+    apt-get install -y python3.7-full python3.7-dev && \
+    update-alternatives --install /usr/bin/python python /usr/bin/python3.7 1 && \
+    update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.7 1
+
+# Install necessary packages
+RUN apt-get update -y && apt-get upgrade -y && apt-get install -y docker.io curl build-essential git jq && \
+    apt-get install -y debmake debhelper-compat && \
+    apt-get install -y libxrender1 libxtst6 libasound2 libxi6 libgconf-2-4 && \
+    apt-get install -y libatk1.0-0 libatk-bridge2.0-0 libcups2 libdrm2 libatspi2.0-dev libxcomposite-dev libxdamage1 libxfixes3 libxfixes-dev libxrandr2 libgbm-dev libxkbcommon-x11-0 libpangocairo-1.0-0 libcairo2 libcairo2-dev libnss3 libnspr4 libnspr4-dev freeglut3 && \
+    apt-get clean -y
+
+# Install pip packages
+RUN curl -SL https://bootstrap.pypa.io/get-pip.py | python && \
+    pip3 install pipenv && pipenv --version && \
+    pip3 install awscli==1.22.12 && aws --version
+
+# Install aptly and required changes to debmake
+# Remove lintian for now due to it takes nearly 20 minutes for OpenSearch as well as nearly an hour for OpenSearch-Dashboards during debmake
+RUN curl -o- https://www.aptly.info/pubkey.txt | apt-key add - && \
+    echo "deb http://repo.aptly.info/ squeeze main" | tee -a /etc/apt/sources.list.d/aptly.list && \
+    apt-get update -y && apt-get install -y aptly && apt-get clean -y && \
+    dpkg -r lintian
+
+# Tools setup
+COPY --chown=0:0 config/jdk-setup.sh config/yq-setup.sh /tmp/
+RUN /tmp/jdk-setup.sh && /tmp/yq-setup.sh
+
+# Create user group
+RUN groupadd -g 1000 opensearch && \
+    useradd -u 1000 -g 1000 -d /usr/share/opensearch opensearch && \
+    mkdir -p /usr/share/opensearch && \
+    chown -R 1000:1000 /usr/share/opensearch 
+
+# Install gh cli
+RUN curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg && \
+    chmod go+r /usr/share/keyrings/githubcli-archive-keyring.gpg && \
+    echo "deb [arch=`dpkg --print-architecture` signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | tee /etc/apt/sources.list.d/github-cli.list && \
+    apt-get update && apt-get install -y gh && apt-get clean
+
+# Change User
+USER 1000
+WORKDIR /usr/share/opensearch

jenkins/opensearch-dashboards/distribution-build.jenkinsfile

@@ -12,6 +12,7 @@ pipeline {
         AGENT_X64 = 'Jenkins-Agent-AL2-X64-C54xlarge-Docker-Host'
         AGENT_ARM64 = 'Jenkins-Agent-AL2-Arm64-C6g4xlarge-Docker-Host'
         IMAGE_RPM = 'opensearchstaging/ci-runner:ci-runner-rockylinux8-opensearch-build-v2' // required for rpm to create digest sha256 correctly with rpm 4.12+
+        IMAGE_DEB = 'opensearchstaging/ci-runner:ci-runner-ubuntu2004-opensearch-build-v1' // required for deb to create pkg using debmake/debuild/debhelper
     }
     parameters {
         string(
@@ -328,6 +329,86 @@ pipeline {
                         }
                     }
                 }
+                stage('build-and-test-linux-x64-deb') {
+                    when {
+                        beforeAgent true
+                        expression{
+                            params.BUILD_PLATFORM.contains('linux')
+                        }
+                    }
+                    agent { label AGENT_X64 }
+                    stages {
+                        stage('build-archive-linux-x64-deb') {
+                            agent {
+                                docker {
+                                    label AGENT_X64
+                                    image dockerAgent.image
+                                    args dockerAgent.args
+                                    alwaysPull true
+                                }
+                            }
+                            steps {
+                                script {
+                                    buildArchive(
+                                        componentName: "${COMPONENT_NAME}",
+                                        inputManifest: "manifests/${INPUT_MANIFEST}",
+                                        platform: 'linux',
+                                        architecture: 'x64',
+                                        distribution: 'deb',
+                                        stashName: "build-archive-linux-x64-deb-${JOB_NAME}-${BUILD_NUMBER}"
+                                    )
+                                }
+                            }
+                            post {
+                                always {
+                                    postCleanup()
+                                }
+                            }
+                        }
+                        stage('assemble-archive-and-test-linux-x64-deb') {
+                            agent {
+                                docker {
+                                    label AGENT_X64
+                                    image IMAGE_DEB
+                                    alwaysPull true
+                                }
+                            }
+                            steps {
+                                script {
+                                    def buildManifestObj = archiveAssembleUpload(
+                                        componentName: "${COMPONENT_NAME}",
+                                        inputManifest: "manifests/${INPUT_MANIFEST}",
+                                        platform: 'linux',
+                                        architecture: 'x64',
+                                        distribution: 'deb',
+                                        stashName: "build-archive-linux-x64-deb-${JOB_NAME}-${BUILD_NUMBER}"
+                                    )
+                                    String buildManifestUrl = buildManifestObj.getUrl(JOB_NAME, BUILD_NUMBER)
+                                    String artifactUrl = buildManifestObj.getArtifactUrl(JOB_NAME, BUILD_NUMBER)
+                                    env.ARTIFACT_URL_LINUX_X64_DEB = artifactUrl
+
+                                    echo "buildManifestUrl (linux, x64, deb): ${buildManifestUrl}"
+                                    echo "artifactUrl (linux, x64, deb): ${artifactUrl}"
+
+                                    String bundleManifestUrl = buildManifestObj.getBundleManifestUrl(JOB_NAME, BUILD_NUMBER)
+
+                                }
+                            }
+                            post {
+                                always {
+                                    script {
+                                        lib.jenkins.Messages.new(this).add(
+                                            "${STAGE_NAME}",
+                                            lib.jenkins.Messages.new(this).get(["${STAGE_NAME}"])
+                                        )
+
+                                        postCleanup()
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
                 stage('build-and-test-linux-arm64-tar') {
                     when {
                         beforeAgent true
@@ -570,6 +651,86 @@ pipeline {
                         }
                     }
                 }
+                stage('build-and-test-linux-arm64-deb') {
+                    when {
+                        beforeAgent true
+                        expression{
+                            params.BUILD_PLATFORM.contains('linux')
+                        }
+                    }
+                    agent { label AGENT_ARM64 }
+                    stages {
+                        stage('build-archive-linux-arm64-deb') {
+                            agent {
+                                docker {
+                                    label AGENT_ARM64
+                                    image dockerAgent.image
+                                    args dockerAgent.args
+                                    alwaysPull true
+                                }
+                            }
+                            steps {
+                                script {
+                                    buildArchive(
+                                        componentName: "${COMPONENT_NAME}",
+                                        inputManifest: "manifests/${INPUT_MANIFEST}",
+                                        platform: 'linux',
+                                        architecture: 'arm64',
+                                        distribution: 'deb',
+                                        stashName: "build-archive-linux-arm64-deb-${JOB_NAME}-${BUILD_NUMBER}"
+                                    )
+                                }
+                            }
+                            post {
+                                always {
+                                    postCleanup()
+                                }
+                            }
+                        }
+                        stage('assemble-archive-and-test-linux-arm64-deb') {
+                            agent {
+                                docker {
+                                    label AGENT_ARM64
+                                    image IMAGE_DEB
+                                    alwaysPull true
+                                }
+                            }
+                            steps {
+                                script {
+                                    def buildManifestObj = archiveAssembleUpload(
+                                        componentName: "${COMPONENT_NAME}",
+                                        inputManifest: "manifests/${INPUT_MANIFEST}",
+                                        platform: 'linux',
+                                        architecture: 'arm64',
+                                        distribution: 'deb',
+                                        stashName: "build-archive-linux-arm64-deb-${JOB_NAME}-${BUILD_NUMBER}"
+                                    )
+                                    String buildManifestUrl = buildManifestObj.getUrl(JOB_NAME, BUILD_NUMBER)
+                                    String artifactUrl = buildManifestObj.getArtifactUrl(JOB_NAME, BUILD_NUMBER)
+                                    env.ARTIFACT_URL_LINUX_ARM64_DEB = artifactUrl
+
+                                    echo "buildManifestUrl (linux, arm64, deb): ${buildManifestUrl}"
+                                    echo "artifactUrl (linux, arm64, deb): ${artifactUrl}"
+
+                                    String bundleManifestUrl = buildManifestObj.getBundleManifestUrl(JOB_NAME, BUILD_NUMBER)
+
+                                }
+                            }
+                            post {
+                                always {
+                                    script {
+                                        lib.jenkins.Messages.new(this).add(
+                                            "${STAGE_NAME}",
+                                            lib.jenkins.Messages.new(this).get(["${STAGE_NAME}"])
+                                        )
+
+                                        postCleanup()
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
                 stage('build-and-test-windows-x64-zip') {
                     when {
                         beforeAgent true
@@ -693,8 +854,10 @@ pipeline {
                         stages = [
                             'build-and-test-linux-x64-tar',
                             'assemble-archive-and-test-linux-x64-rpm',
+                            'assemble-archive-and-test-linux-x64-deb',
                             'assemble-archive-and-test-linux-arm64-tar',
                             'assemble-archive-and-test-linux-arm64-rpm',
+                            'assemble-archive-and-test-linux-arm64-deb',
                         ]
                     }
                     if (params.BUILD_PLATFORM.contains('windows')){