remove scripts no longer in use
As far as I know, these scripts are not used anywhere and have not been
updated in years (other then required formatting changes).
Change-Id: I1264cce4ad3a97e397743391614b1627fc008565
Signed-off-by: Andrew Geissler <geissonator@yahoo.com>
diff --git a/build-jenkins.sh b/build-jenkins.sh
deleted file mode 100755
index bba849a..0000000
--- a/build-jenkins.sh
+++ /dev/null
@@ -1,267 +0,0 @@
-#!/bin/bash
-################################################################################
-#
-# Script used to create a Jenkins master that can run amd64 or ppc64le. It can
-# be used to launch the Jenkins master as a Docker container locally or as a
-# Kubernetes Deployment in a Kubernetes cluster.
-#
-################################################################################
-#
-# Script Variables:
-# build_scripts_dir The path of the openbmc-build-scripts directory.
-# Default: The directory containing this script
-# workspace The directory that holds files used to build the Jenkins
-# master master image and volumes used to deploy it.
-# Default: "~/jenkins-build-${RANDOM}"
-#
-# Jenkins Dockerfile Variables:
-# agent_port The port used as the Jenkins slave agent port.
-# Default: "50000"
-# http_port The port used as Jenkins UI port.
-# Default: "8080"
-# img_name The name given to the Docker image when it is built.
-# Default: "openbmc/jenkins-master-${ARCH}:${JENKINS_VRSN}"
-# img_tag The tag of the OpenJDK image used as the base image.
-# Default: "/8-jdk"
-# j_gid Jenkins group ID the container will use to run Jenkins.
-# Default: "1000"
-# j_group Group name tag the container will use to run Jenkins.
-# Default: "jenkins"
-# j_home Directory used as the Jenkins Home in the container.
-# Default: "/var/jenkins_home"
-# j_uid Jenkins user ID the container will use to run Jenkins.
-# Default: "1000"
-# j_user Username tag the container will use to run Jenkins.
-# Default: "jenkins"
-# j_vrsn The version of the Jenkins war file you wish to use.
-# Default: "2.60.3"
-# tini_vrsn The version of Tini to use in the Dockerfile, 0.16.1 is
-# the first release with ppc64le release support.
-# Default: "0.16.1"
-#
-# Deployment Variables:
-# cont_import_mnt The directory on the container used to import extra files.
-# Default: "/mnt/jenkins_import", ignored if above not set
-# home_mnt The directory on the host used as the Jenkins home.
-# Default: "${WORKSPACE}/jenkins_home"
-# host_import_mnt The directory on the host used to import extra files.
-# Default: "", import mount is ignored if not set
-# java_options What will be passed as the environment variable for the
-# JAVA_OPTS environment variable.
-# Default: "-Xmx4096m"
-# jenkins_options What will be passed as the environment variable for the
-# JENKINS_OPTS environment variable.
-# Default: "--prefix=/jenkins"
-# launch docker|k8s
-# Method in which the container will be launched. Either as
-# a Docker container launched via Docker, or by using a
-# helper script to launch into a Kubernetes cluster.
-# Default: "docker"
-#
-################################################################################
-set -xeo pipefail
-ARCH=$(uname -m)
-
-# Script Variables
-build_scripts_dir=${build_scripts_dir:-"$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"}
-workspace=${workspace:-${HOME}/jenkins-build-${RANDOM}}
-
-# Jenkins Dockerfile Variables
-agent_port=${agent_port:-50000}
-http_port=${http_port:-8080}
-img_name=${img_name:-openbmc/jenkins-master-${ARCH}:${j_vrsn}}
-j_gid=${j_gid:-1000}
-j_group=${j_group:-jenkins}
-j_home=${j_home:-/var/jenkins_home}
-j_uid=${j_uid:-1000}
-j_user=${j_user:-jenkins}
-j_vrsn=${j_vrsn:-2.60.3}
-img_tag=${img_tag:-8-jdk}
-tini_vrsn=${tini_vrsn:-0.16.1}
-
-# Deployment Variables
-cont_import_mnt=${cont_import_mnt:-/mnt/jenkins_import}
-home_mnt=${home_mnt:-${workspace}/jenkins_home}
-host_import_mnt=${host_import_mnt:-}
-java_options=${java_options:-"-Xmx4096m"}
-jenkins_options=${jenkins_options:-"--prefix=/jenkins"}
-launch=${launch:-docker}
-
-# Save the Jenkins.war URL to a variable and SHA if we care about verification
-j_url=https://repo.jenkins-ci.org/public/org/jenkins-ci/main/jenkins-war/${j_vrsn}/jenkins-war-${j_vrsn}.war
-
-# Make or Clean WORKSPACE
-if [[ -d "${workspace}" ]]; then
- rm -rf "${workspace}/Dockerfile" \
- "${workspace}/docker-jenkins" \
- "${workspace}/plugins.*" \
- "${workspace}/install-plugins.sh" \
- "${workspace}/jenkins.sh" \
- "${workspace}/jenkins-support" \
- "${workspace}/init.groovy"
-else
- mkdir -p "${workspace}"
-fi
-
-# Determine the prefix of the Dockerfile's base image
-case ${ARCH} in
- "ppc64le")
- docker_base="ppc64le/"
- tini_arch="ppc64el"
- ;;
- "x86_64")
- docker_base=""
- tini_arch="amd64"
- ;;
- "aarch64")
- docker_base="arm64v8/"
- tini_arch="arm64"
- ;;
- *)
- echo "Unsupported system architecture(${ARCH}) found for docker image"
- exit 1
-esac
-
-# Move Into the WORKSPACE
-cd "${workspace}"
-
-# Make the Dockerfile
-################################################################################
-cat >> Dockerfile << EOF
-FROM ${docker_base}openjdk:${img_tag}
-
-RUN apt-get update && apt-get install -y git curl
-
-ENV JENKINS_HOME ${j_home}
-ENV JENKINS_SLAVE_AGENT_PORT ${agent_port}
-
-# Jenkins will default to run with user jenkins, uid = 1000
-# If you bind mount a volume from the host or a data container,
-# ensure you use the same uid
-RUN groupadd -g ${j_gid} ${j_group} && \
- useradd -d ${j_home} -u ${j_uid} -g ${j_gid} -m -s /bin/bash ${j_user}
-
-# Jenkins home directory is a volume, so configuration and build history
-# can be persisted and survive image upgrades
-VOLUME ${j_home}
-
-# /usr/share/jenkins/ref/ contains all reference configuration we want
-# to set on a fresh new installation. Use it to bundle additional plugins
-# or config file with your custom jenkins Docker image.
-RUN mkdir -p /usr/share/jenkins/ref/init.groovy.d
-
-# Use tini as subreaper in Docker container to adopt zombie processes
-RUN curl -fsSL https://github.com/krallin/tini/releases/download/v${tini_vrsn}/tini-static-${tini_arch} \
- -o /bin/tini && \
- chmod +x /bin/tini
-
-COPY init.groovy /usr/share/jenkins/ref/init.groovy.d/tcp-slave-agent-port.groovy
-
-# could use ADD but this one does not check Last-Modified header neither does it allow to control checksum
-# see https://github.com/docker/docker/issues/8331
-RUN curl -fsSL ${j_url} -o /usr/share/jenkins/jenkins.war
-
-ENV JENKINS_UC https://updates.jenkins.io
-ENV JENKINS_UC_EXPERIMENTAL=https://updates.jenkins.io/experimental
-RUN chown -R ${j_user} ${j_home} /usr/share/jenkins/ref
-
-# for main web interface:
-EXPOSE ${http_port}
-
-# will be used by attached slave agents:
-EXPOSE ${agent_port}
-
-ENV COPY_REFERENCE_FILE_LOG ${j_home}/copy_reference_file.log
-USER ${j_user}
-
-COPY jenkins-support /usr/local/bin/jenkins-support
-COPY jenkins.sh /usr/local/bin/jenkins.sh
-ENTRYPOINT ["/bin/tini", "--", "/usr/local/bin/jenkins.sh"]
-
-# from a derived Dockerfile, can use RUN plugins.sh active.txt to setup /usr/share/jenkins/ref/plugins from a support bundle
-COPY plugins.sh /usr/local/bin/plugins.sh
-COPY install-plugins.sh /usr/local/bin/install-plugins.sh
-
-# Install plugins.txt plugins
-COPY plugins.txt /usr/share/jenkins/ref/plugins.txt
-RUN /usr/local/bin/install-plugins.sh < /usr/share/jenkins/ref/plugins.txt
-EOF
-################################################################################
-
-# Clone in the jenkinsci docker jenkins repo and copy some files into WORKSPACE
-git clone https://github.com/jenkinsci/docker.git docker-jenkins
-cp docker-jenkins/init.groovy .
-cp docker-jenkins/jenkins-support .
-cp docker-jenkins/jenkins.sh .
-cp docker-jenkins/plugins.sh .
-cp docker-jenkins/install-plugins.sh .
-
-# Generate Plugins.txt, the plugins you want installed automatically go here
-################################################################################
-cat >> plugins.txt << EOF
-kubernetes
-EOF
-################################################################################
-
-# Build the image
-docker build -t "${img_name}" .
-
-if [[ "${launch}" == "docker" ]]; then
-
- # Ensure directories that will be mounted exist
- if [[ -n "${host_import_mnt}" && ! -d "${host_import_mnt}" ]]; then
- mkdir -p "${host_import_mnt}"
- fi
-
- if [[ ! -d "${home_mnt}" ]]; then
- mkdir -p "${home_mnt}"
- fi
-
- # Ensure directories that will be mounted are owned by the jenkins user
- if [[ "$(id -u)" != 0 ]]; then
- echo "Not running as root:"
- echo "Checking if j_gid and j_uid are the owners of mounted directories"
- # shellcheck disable=SC2012 # use ls to get permissions.
- test_1="$(ls -nd "${home_mnt}" | awk '{print $3 " " $4}')"
- if [[ "${test_1}" != "${j_uid} ${j_gid}" ]]; then
- echo "Owner of ${home_mnt} is not the jenkins user"
- echo "${test_1} != ${j_uid} ${j_gid}"
- will_fail=1
- fi
- if [[ -n "${host_import_mnt}" ]]; then
- # shellcheck disable=SC2012 # use ls to get permissions.
- test_2="$(ls -nd "${host_import_mnt}" | awk '{print $3 " " $4}' )"
- if [[ "${test_2}" != "${j_uid} ${j_gid}" ]]; then
- echo "Owner of ${host_import_mnt} is not the jenkins user"
- echo "${test_2} != ${j_uid} ${j_gid}"
- will_fail=1
- fi
- fi
- if [[ "${will_fail}" == 1 ]]; then
- echo "Failing before attempting to launch container"
- echo "Try again as root or use correct uid/gid pairs"
- exit 1
- fi
- else
- if [[ -n "${host_import_mnt}" ]]; then
- chown -R "${j_uid}:${j_gid}" "${host_import_mnt}"
- fi
- chown -R "${j_uid}:${j_gid}" "${home_mnt}"
- fi
-
- #If we don't have import mount don't add to docker command
- if [[ -n "${host_import_mnt}" ]]; then
- import_vol_cmd="-v ${host_import_mnt}:${cont_import_mnt}"
- fi
- # Launch the jenkins image with Docker
- # shellcheck disable=SC2086 # import_vol_cmd is intentionally word-split.
- docker run -d \
- ${import_vol_cmd} \
- -v "${home_mnt}:${j_home}" \
- -p "${http_port}:8080" \
- -p "${agent_port}:${agent_port}" \
- --env JAVA_OPTS=\""${java_options}"\" \
- --env JENKINS_OPTS=\""${jenkins_options}"\" \
- "${img_name}"
-
-fi
diff --git a/docs-build.sh b/docs-build.sh
deleted file mode 100755
index 438c3d7..0000000
--- a/docs-build.sh
+++ /dev/null
@@ -1,74 +0,0 @@
-#!/bin/bash
-
-# This build script is for running the Jenkins builds using docker.
-#
-
-# Trace bash processing
-set -x
-
-# Default variables
-WORKSPACE=${WORKSPACE:-${HOME}/${RANDOM}${RANDOM}}
-http_proxy=${http_proxy:-}
-
-# Timestamp for job
-echo "Build started, $(date)"
-
-# Configure docker build
-if [[ -n "${http_proxy}" ]]; then
- PROXY="RUN echo \"Acquire::http::Proxy \\"\"${http_proxy}/\\"\";\" > /etc/apt/apt.conf.d/000apt-cacher-ng-proxy"
-fi
-
-Dockerfile=$(cat << EOF
-FROM ubuntu:16.04
-
-${PROXY}
-
-ENV DEBIAN_FRONTEND noninteractive
-RUN apt-get update && apt-get install -yy \
- make \
- texlive-xetex \
- pandoc \
- fonts-inconsolata \
- fonts-linuxlibertine
-
-RUN grep -q ${GROUPS[0]} /etc/group || groupadd -g ${GROUPS[0]} ${USER}
-RUN grep -q ${UID} /etc/passwd || useradd -d ${HOME} -m -u ${UID} -g ${GROUPS[0]} ${USER}
-
-USER ${USER}
-ENV HOME ${HOME}
-RUN /bin/bash
-EOF
-)
-
-# Build the docker container
-if ! docker build -t linux-build/ubuntu - <<< "${Dockerfile}" ; then
- echo "Failed to build docker container."
- exit 1
-fi
-
-# Create the docker run script
-export PROXY_HOST=${http_proxy/#http*:\/\/}
-export PROXY_HOST=${PROXY_HOST/%:[0-9]*}
-export PROXY_PORT=${http_proxy/#http*:\/\/*:}
-
-mkdir -p "${WORKSPACE}"
-
-cat > "${WORKSPACE}"/build.sh << EOF_SCRIPT
-#!/bin/bash
-
-set -x
-
-cd ${WORKSPACE}
-
-# Go into the linux directory (the script will put us in a build subdir)
-cd docs
-
-make
-
-EOF_SCRIPT
-
-chmod a+x "${WORKSPACE}/build.sh"
-
-# Run the docker container, execute the build script we just built
-docker run --cap-add=sys_admin --net=host --rm=true -e WORKSPACE="${WORKSPACE}" --user="${USER}" \
- -w "${HOME}" -v "${HOME}":"${HOME}" -t linux-build/ubuntu "${WORKSPACE}/build.sh"
diff --git a/initramfs-build.sh b/initramfs-build.sh
deleted file mode 100755
index f3af769..0000000
--- a/initramfs-build.sh
+++ /dev/null
@@ -1,161 +0,0 @@
-#!/bin/bash
-
-# This build script is for running the Jenkins builds using docker.
-#
-
-# Debug
-if grep -q debug <<< "$@"; then
- set -x
-fi
-set -o errexit
-set -o pipefail
-set -o nounset
-
-# Default variables
-WORKSPACE=${WORKSPACE:-${HOME}/${RANDOM}${RANDOM}}
-http_proxy=${http_proxy:-}
-ENDIANNESS=${ENDIANNESS:-le}
-PROXY=""
-
-function usage() {
- cat << EOF_USAGE
-Usage: $0 [options]
-
-Options:
---endianness <le|be> build an LE or BE initramfs
-
-Short Options:
--e same as --endianness
-
-EOF_USAGE
- exit 1
-}
-
-# Arguments
-CMD_LINE=$(getopt -o d,e: --longoptions debug,endianness: -n "$0" -- "$@")
-eval set -- "${CMD_LINE}"
-
-while true ; do
- case "${1}" in
- -e|--endianness)
- if [[ "${2,,}" == "be" ]]; then
- ENDIANNESS=""
- fi
- shift 2
- ;;
- -d|--debug)
- set -x
- shift
- ;;
- --)
- shift
- break
- ;;
- *)
- usage
- ;;
- esac
-done
-
-# Timestamp for job
-echo "Build started, $(date)"
-
-# Configure docker build
-if [[ -n "${http_proxy}" ]]; then
- PROXY="RUN echo \"Acquire::http::Proxy \\"\"${http_proxy}/\\"\";\" > /etc/apt/apt.conf.d/000apt-cacher-ng-proxy"
-fi
-
-Dockerfile=$(cat << EOF
-FROM ubuntu:18.04
-
-${PROXY}
-
-ENV DEBIAN_FRONTEND noninteractive
-RUN apt-get update && apt-get install -yy \
- bc \
- build-essential \
- ccache \
- cpio \
- git \
- python \
- unzip \
- wget \
- rsync \
- iputils-ping \
- locales
-
-RUN grep -q ${GROUPS[0]} /etc/group || groupadd -g ${GROUPS[0]} ${USER}
-RUN grep -q ${UID} /etc/passwd || useradd -d ${HOME} -m -u ${UID} -g ${GROUPS[0]} ${USER}
-
-RUN locale-gen en_AU.utf8
-
-USER ${USER}
-ENV HOME ${HOME}
-RUN /bin/bash
-EOF
-)
-
-# Build the docker container
-if ! docker build -t initramfs-build/ubuntu - <<< "${Dockerfile}" ; then
- echo "Failed to build docker container."
- exit 1
-fi
-
-# Create the docker run script
-export PROXY_HOST=${http_proxy/#http*:\/\/}
-export PROXY_HOST=${PROXY_HOST/%:[0-9]*}
-export PROXY_PORT=${http_proxy/#http*:\/\/*:}
-
-mkdir -p "${WORKSPACE}"
-
-cat > "${WORKSPACE}/build.sh" << EOF_SCRIPT
-#!/bin/bash
-
-set -x
-
-export http_proxy=${http_proxy}
-export https_proxy=${http_proxy}
-export ftp_proxy=${http_proxy}
-
-cd "${WORKSPACE}"
-
-# Go into the linux directory (the script will put us in a build subdir)
-cd buildroot && make clean
-
-# Build PPC64 defconfig
-cat >> configs/powerpc64${ENDIANNESS}_openpower_defconfig << EOF_BUILDROOT
-BR2_powerpc64${ENDIANNESS}=y
-BR2_CCACHE=y
-BR2_SYSTEM_BIN_SH_BASH=y
-BR2_TARGET_GENERIC_GETTY_PORT="hvc0"
-BR2_PACKAGE_BUSYBOX_SHOW_OTHERS=y
-BR2_TARGET_ROOTFS_CPIO=y
-BR2_TARGET_ROOTFS_CPIO_XZ=y
-BR2_PACKAGE_IPMITOOL=y
-# BR2_TARGET_ROOTFS_TAR is not set
-EOF_BUILDROOT
-
-# Build buildroot
-export BR2_DL_DIR="${HOME}/buildroot_downloads"
-make powerpc64${ENDIANNESS}_openpower_defconfig
-make
-
-EOF_SCRIPT
-
-chmod a+x "${WORKSPACE}/build.sh"
-
-# Run the docker container, execute the build script we just built
-docker run \
- --cap-add=sys_admin \
- --net=host \
- --rm=true \
- -e WORKSPACE="${WORKSPACE}" \
- --user="${USER}" \
- -w "${HOME}" \
- -v "${HOME}":"${HOME}" \
- -t initramfs-build/ubuntu \
- "${WORKSPACE}/build.sh"
-
-# Timestamp for build
-echo "Build completed, $(date)"
-
diff --git a/kernel-build-setup.sh b/kernel-build-setup.sh
deleted file mode 100755
index 6b5d6f4..0000000
--- a/kernel-build-setup.sh
+++ /dev/null
@@ -1,134 +0,0 @@
-#!/bin/bash
-
-# This build script is for running the Jenkins builds using docker.
-#
-# It expects a variable as part of Jenkins build job matrix:
-# distro = fedora|ubuntu
-# WORKSPACE =
-
-# Trace bash processing
-set -x
-
-# Default variables
-distro=${distro:-ubuntu}
-WORKSPACE=${WORKSPACE:-${HOME}/${RANDOM}${RANDOM}}
-http_proxy=${http_proxy:-}
-
-# Timestamp for job
-echo "Build started, $(date)"
-
-# Configure docker build
-if [[ "${distro}" == fedora ]];then
-
- if [[ -n "${http_proxy}" ]]; then
- PROXY="RUN echo \"proxy=${http_proxy}\" >> /etc/dnf/dnf.conf"
- fi
-
- Dockerfile=$(cat << EOF
-FROM fedora:latest
-
-${PROXY}
-
-RUN dnf --refresh install -y \
- bc \
- findutils \
- git \
- gcc \
- gcc-arm-linux-gnu \
- hostname \
- make \
- uboot-tools xz
-
-RUN grep -q ${GROUPS[0]} /etc/group || groupadd -g ${GROUPS[0]} ${USER}
-RUN grep -q ${UID} /etc/passwd || useradd -d ${HOME} -m -u ${UID} -g ${GROUPS[0]} ${USER}
-
-USER ${USER}
-ENV HOME ${HOME}
-RUN /bin/bash
-EOF
- )
-
-elif [[ "${distro}" == ubuntu ]]; then
- if [[ -n "${http_proxy}" ]]; then
- PROXY="RUN echo \"Acquire::http::Proxy \\"\"${http_proxy}/\\"\";\" > /etc/apt/apt.conf.d/000apt-cacher-ng-proxy"
- fi
-
- Dockerfile=$(cat << EOF
-FROM ubuntu:latest
-
-${PROXY}
-
-ENV DEBIAN_FRONTEND noninteractive
-RUN apt-get update && apt-get install -yy \
- bc \
- build-essential \
- git \
- gcc-arm-linux-gnueabi \
- binutils-arm-linux-gnueabi \
- libssl-dev \
- bison \
- flex \
- u-boot-tools
-
-RUN grep -q ${GROUPS[0]} /etc/group || groupadd -g ${GROUPS[0]} ${USER}
-RUN grep -q ${UID} /etc/passwd || useradd -d ${HOME} -m -u ${UID} -g ${GROUPS[0]} ${USER}
-
-USER ${USER}
-ENV HOME ${HOME}
-RUN /bin/bash
-EOF
- )
-fi
-
-# Build the docker container
-if ! docker build -t "linux-aspeed/${distro}" - <<< "${Dockerfile}" ; then
- echo "Failed to build docker container."
- exit 1
-fi
-
-# Create the docker run script
-export PROXY_HOST=${http_proxy/#http*:\/\/}
-export PROXY_HOST=${PROXY_HOST/%:[0-9]*}
-export PROXY_PORT=${http_proxy/#http*:\/\/*:}
-
-mkdir -p "${WORKSPACE}"
-
-cat > "${WORKSPACE}"/build.sh << EOF_SCRIPT
-#!/bin/bash
-
-set -x
-
-cd ${WORKSPACE}
-
-# Go into the linux-aspeed directory (the script will put us in a build subdir)
-cd linux-aspeed
-
-# Configure a build
-if [ "${distro}" == "fedora" ]; then
- CROSS_COMPILER="arm-linux-gnu-"
-else
- CROSS_COMPILER="arm-linux-gnueabi-"
-fi
-
-# Record the version in the logs
-$\{CROSS_COMPILER}gcc --version
-
-ARCH=arm CROSS_COMPILE=\${CROSS_COMPILER} make aspeed_defconfig
-ARCH=arm CROSS_COMPILE=\${CROSS_COMPILER} make -j$(($(nproc) / 4))
-
-# build palmetto image
-ARCH=arm CROSS_COMPILE=\${CROSS_COMPILER} make aspeed-bmc-opp-palmetto.dtb
-cat arch/arm/boot/zImage arch/arm/boot/dts/aspeed-bmc-opp-palmetto.dtb > palmetto-zimage
-./scripts/mkuboot.sh -A arm -O linux -C none -T kernel -a 0x40008000 -e 0x40008000 -d-e 0x40008000 -n obmc-palm-\$(date +%Y%m%d%H%M) -d palmetto-zimage uImage.palmetto
-
-EOF_SCRIPT
-
-chmod a+x "${WORKSPACE}"/build.sh
-
-# Run the docker container, execute the build script we just built
-docker run --cap-add=sys_admin --net=host --rm=true -e WORKSPACE="${WORKSPACE}" --user="${USER}" \
- -w "${HOME}" -v "${HOME}":"${HOME}" -t linux-aspeed/"${distro}" "${WORKSPACE}"/build.sh
-
-# Timestamp for build
-echo "Build completed, $(date)"
-
diff --git a/kernel-build.sh b/kernel-build.sh
deleted file mode 100755
index 22348ea..0000000
--- a/kernel-build.sh
+++ /dev/null
@@ -1,109 +0,0 @@
-#!/bin/bash
-
-# This build script is for running the Jenkins builds using docker.
-#
-
-# Trace bash processing
-#set -x
-
-# Default variables
-WORKSPACE=${WORKSPACE:-${HOME}/${RANDOM}${RANDOM}}
-http_proxy=${http_proxy:-}
-
-# Timestamp for job
-echo "Build started, $(date)"
-
-# Configure docker build
-if [[ -n "${http_proxy}" ]]; then
- PROXY="RUN echo \"Acquire::http::Proxy \\"\"${http_proxy}/\\"\";\" > /etc/apt/apt.conf.d/000apt-cacher-ng-proxy"
-fi
-
-Dockerfile=$(cat << EOF
-FROM ubuntu:latest
-
-${PROXY}
-
-ENV DEBIAN_FRONTEND noninteractive
-RUN apt-get update && apt-get install -yy \
- bc \
- build-essential \
- git \
- gcc-powerpc64le-linux-gnu \
- software-properties-common \
- libssl-dev \
- bison \
- flex \
- iputils-ping
-
-RUN apt-add-repository -y multiverse && apt-get update && apt-get install -yy \
- dwarves \
- sparse
-
-RUN grep -q ${GROUPS[0]} /etc/group || groupadd -g ${GROUPS[0]} ${USER}
-RUN grep -q ${UID} /etc/passwd || useradd -d ${HOME} -m -u ${UID} -g ${GROUPS[0]} ${USER}
-
-USER ${USER}
-ENV HOME ${HOME}
-RUN /bin/bash
-EOF
-)
-
-# Build the docker container
-if ! docker build -t linux-build/ubuntu - <<< "${Dockerfile}" ; then
- echo "Failed to build docker container."
- exit 1
-fi
-
-# Create the docker run script
-export PROXY_HOST=${http_proxy/#http*:\/\/}
-export PROXY_HOST=${PROXY_HOST/%:[0-9]*}
-export PROXY_PORT=${http_proxy/#http*:\/\/*:}
-
-mkdir -p "${WORKSPACE}"
-
-cat > "${WORKSPACE}"/build.sh << EOF_SCRIPT
-#!/bin/bash
-
-set -x
-set -e -o pipefail
-
-cd "${WORKSPACE}"
-
-# Go into the linux directory (the script will put us in a build subdir)
-cd linux
-
-# Record the version in the logs
-powerpc64le-linux-gnu-gcc --version
-
-# Build kernel prep
-ARCH=powerpc CROSS_COMPILE=powerpc64le-linux-gnu- make mrproper
-
-# Build kernel
-ARCH=powerpc CROSS_COMPILE=powerpc64le-linux-gnu- make -s pseries_le_defconfig
-ARCH=powerpc CROSS_COMPILE=powerpc64le-linux-gnu- make -s -j$(nproc)
-
-# Build kernel with debug
-ARCH=powerpc CROSS_COMPILE=powerpc64le-linux-gnu- make -s pseries_le_defconfig
-echo "CONFIG_DEBUG_INFO=y" >> .config
-# Enable virtio-net driver for QEMU virtio-net-pci driver
-echo "CONFIG_VIRTIO=y" >> .config
-echo "CONFIG_VIRTIO_NET=y" >> .config
-echo "CONFIG_VIRTIO_PCI=y" >> .config
-ARCH=powerpc CROSS_COMPILE=powerpc64le-linux-gnu- make olddefconfig
-ARCH=powerpc CROSS_COMPILE=powerpc64le-linux-gnu- make -j$(nproc) -s C=2 CF=-D__CHECK_ENDIAN__ 2>&1 | gzip > sparse.log.gz
-pahole vmlinux 2>&1 | gzip > structs.dump.gz
-
-EOF_SCRIPT
-
-chmod a+x "${WORKSPACE}"/build.sh
-
-# Run the docker container, execute the build script we just built
-docker run --cap-add=sys_admin --net=host --rm=true -e WORKSPACE="${WORKSPACE}" --user="${USER}" \
- -w "${WORKSPACE}" -v "${WORKSPACE}":"${WORKSPACE}" -t linux-build/ubuntu "${WORKSPACE}"/build.sh
-
-result=${?}
-
-# Timestamp for build
-echo "Build completed, $(date)"
-
-exit ${result}
diff --git a/openpower-build-setup.sh b/openpower-build-setup.sh
deleted file mode 100755
index efb3ebc..0000000
--- a/openpower-build-setup.sh
+++ /dev/null
@@ -1,183 +0,0 @@
-#!/bin/bash
-
-# This build script is for running the Jenkins builds using docker.
-#
-# It expects a few variables which are part of Jenkins build job matrix:
-# target = palmetto|qemu|habanero|firestone|garrison
-# distro = ubuntu|fedora
-# WORKSPACE = Random Number by Default
-
-# Trace bash processing
-set -x
-
-# Default variables
-target=${target:-palmetto}
-distro=${distro:-ubuntu}
-WORKSPACE=${WORKSPACE:-${HOME}/${RANDOM}${RANDOM}}
-
-# Timestamp for job
-echo "Build started, $(date)"
-
-# if there is no open-power directory clone in master into workspace
-if [ ! -e "${WORKSPACE}"/op-build ]; then
- echo "Clone in openpower master to ${WORKSPACE}/op-build"
- git clone --recursive https://github.com/open-power/op-build "${WORKSPACE}"/op-build
-fi
-
-# Determine the architecture
-ARCH=$(uname -m)
-
-# Determine the prefix of the Dockerfile's base image
-case ${ARCH} in
- "ppc64le")
- DOCKER_BASE="ppc64le/"
- ;;
- "x86_64")
- DOCKER_BASE=""
- ;;
- "aarch64")
- DOCKER_BASE="arm64v8/"
- ;;
- *)
- echo "Unsupported system architecture(${ARCH}) found for docker image"
- exit 1
-esac
-
-
-# Configure docker build
-if [[ "${distro}" == fedora ]];then
-
- Dockerfile=$(cat << EOF
-FROM ${DOCKER_BASE}fedora:latest
-
-RUN dnf --refresh repolist && dnf install -y \
- bc \
- bison \
- bzip2 \
- cpio \
- cscope \
- ctags \
- expat-devel \
- findutils \
- flex \
- gcc-c++ \
- git \
- libxml2-devel \
- ncurses-devel \
- openssl-devel \
- patch \
- perl \
- perl-bignum \
- "perl(Digest::SHA1)" \
- "perl(Env)" \
- "perl(Fatal)" \
- "perl(Thread::Queue)" \
- "perl(XML::SAX)" \
- "perl(XML::Simple)" \
- "perl(YAML)" \
- "perl(XML::LibXML)" \
- python \
- python3 \
- tar \
- unzip \
- vim \
- wget \
- which \
- zlib-devel \
- zlib-static \
- iputils-ping
-
-RUN grep -q ${GROUPS[0]} /etc/group || groupadd -g ${GROUPS[0]} ${USER}
-RUN grep -q ${UID} /etc/passwd || useradd -d ${HOME} -m -u ${UID} -g ${GROUPS[0]} ${USER}
-
-USER ${USER}
-ENV HOME ${HOME}
-RUN /bin/bash
-EOF
- )
-
-elif [[ "${distro}" == ubuntu ]]; then
-
- Dockerfile=$(cat << EOF
-FROM ${DOCKER_BASE}ubuntu:latest
-
-ENV DEBIAN_FRONTEND noninteractive
-RUN apt-get update && apt-get install -yy \
- bc \
- bison \
- build-essential \
- cscope \
- cpio \
- ctags \
- flex \
- g++ \
- git \
- libssl-dev \
- libexpat-dev \
- libz-dev \
- libxml-sax-perl \
- libxml-simple-perl \
- libxml2-dev \
- libxml2-utils \
- language-pack-en \
- python \
- python3 \
- texinfo \
- unzip \
- vim-common \
- wget\
- xsltproc \
- libssl-dev \
- iputils-ping
-
-RUN grep -q ${GROUPS[0]} /etc/group || groupadd -g ${GROUPS[0]} ${USER}
-RUN grep -q ${UID} /etc/passwd || useradd -d ${HOME} -m -u ${UID} -g ${GROUPS[0]} ${USER}
-
-USER ${USER}
-ENV HOME ${HOME}
-RUN /bin/bash
-EOF
- )
-fi
-
-# Build the docker container
-if ! docker build -t op-build/"${distro}" - <<< "${Dockerfile}" ; then
- echo "Failed to build docker container."
- exit 1
-fi
-
-mkdir -p "${WORKSPACE}"
-
-cat > "${WORKSPACE}"/build.sh << EOF_SCRIPT
-#!/bin/bash
-
-set -x
-
-# This ensures that the alias set in op-build-env is
-# available in this script
-shopt -s expand_aliases
-
-cd "${WORKSPACE}"/op-build
-
-# Source our build env
-. op-build-env
-
-# Configure
-op-build "${target}_defconfig"
-
-# Kick off a build
-op-build
-
-EOF_SCRIPT
-
-chmod a+x "${WORKSPACE}"/build.sh
-
-# Run the docker container, execute the build script we just built
-docker run --net=host --rm=true -e WORKSPACE="${WORKSPACE}" --user="${USER}" \
- -w "${HOME}" -v "${HOME}":"${HOME}" -t op-build/"${distro}" "${WORKSPACE}"/build.sh
-
-# Create link to images for archiving
-ln -sf "${WORKSPACE}"/op-build/output/images "${WORKSPACE}"/images
-
-# Timestamp for build
-echo "Build completed, $(date)"
diff --git a/test-distro.sh b/test-distro.sh
deleted file mode 100755
index 394567b..0000000
--- a/test-distro.sh
+++ /dev/null
@@ -1,104 +0,0 @@
-#!/bin/bash
-
-set -eou pipefail
-set -x
-
-function util_ensure_available() {
- local bin=$1
- if ! which "${bin}"
- then
- echo "Please install ${bin}"
- return 1
- fi
- return 0
-}
-
-function jenkins_get_job_config() {
- local host="$1"
- local job="$2"
- local config
- config="$(mktemp --suffix=.xml config.XXXXXX)"
- local url="https://${host}/job/${job}/config.xml"
- wget --output-document="${config}" "${url}"
- echo "${config}"
-}
-
-function jenkins_get_job_repos() {
- local config="$1"
- if [ -n "${REPO}" ]
- then
- echo "${REPO}"
- return 0
- fi
- # xmllint is rubbish, so we need sed(1) to separate the results
- xmllint --xpath '//com.sonyericsson.hudson.plugins.gerrit.trigger.hudsontrigger.data.GerritProject/pattern' "${config}" | sed -e 's/<pattern>//g' -e 's/<\/pattern>/\n/g'
-}
-
-: "${JENKINS_HOST:=openpower.xyz}"
-: "${JENKINS_JOB:=openbmc-repository-ci}"
-
-util_ensure_available wget
-util_ensure_available xmllint
-util_ensure_available git
-
-CONFIG=
-REPO=
-
-while [[ $# -gt 0 ]]
-do
- key="$1"
- case "${key}" in
- -c|--config)
- CONFIG="$2"
- shift 2
- ;;
- -r|--repo|--repository)
- REPO="$2"
- shift 2
- ;;
- -h|--help)
- echo "USAGE: DISTRO=DOCKERBASE $0 --config config.xml"
- echo
- echo "DOCKERBASE is the Docker Hub tag of the base image against which to"
- echo "build and test the repositories described in config.xml. Individual"
- echo "repositories can be tested against DOCKERBASE with the --repository"
- echo "option \(in place of --config\)."
- exit 0
- ;;
- *)
- (>&2 echo Unrecognised argument \'"$1"\')
- shift
- ;;
- esac
-done
-
-if [ -z "${CONFIG}" ]
-then
- CONFIG="$(jenkins_get_job_config "${JENKINS_HOST}" "${JENKINS_JOB}")"
-fi
-
-export UNIT_TEST_PKG=
-export WORKSPACE=
-
-function git_clone_repo() {
- local prj_package="$1"
- local package
- package="$(basename "${prj_package}")"
- local workspace="$2"
- if [ -d "${prj_package}" ]
- then
- git clone "${prj_package}" "${workspace}"/"${package}"
- return
- fi
- git clone https://gerrit.openbmc.org/openbmc/"${package}" "${workspace}"/"${package}"
-}
-
-jenkins_get_job_repos "${CONFIG}" | while read -r GERRIT_PROJECT
-do
- UNIT_TEST_PKG=$(basename "${GERRIT_PROJECT}")
- WORKSPACE="$(mktemp -d --tmpdir openbmc-build-scripts.XXXXXX)"
- git clone . "${WORKSPACE}"/openbmc-build-scripts
- git_clone_repo "${GERRIT_PROJECT}" "${WORKSPACE}"
- ./run-unit-test-docker.sh
- rm -rf "${WORKSPACE}"
-done
diff --git a/trace-kernel-build.sh b/trace-kernel-build.sh
deleted file mode 100755
index 63691e2..0000000
--- a/trace-kernel-build.sh
+++ /dev/null
@@ -1,111 +0,0 @@
-#!/bin/bash
-
-# This build script is for running the Jenkins builds using docker.
-#
-
-# Trace bash processing
-#set -x
-
-# Default variables
-WORKSPACE=${WORKSPACE:-${HOME}/${RANDOM}${RANDOM}}
-http_proxy=${http_proxy:-}
-
-# Timestamp for job
-echo "Build started, $(date)"
-
-# Configure docker build
-if [[ -n "${http_proxy}" ]]; then
- PROXY="RUN echo \"Acquire::http::Proxy \\"\"${http_proxy}/\\"\";\" > /etc/apt/apt.conf.d/000apt-cacher-ng-proxy"
-fi
-
-Dockerfile=$(cat << EOF
-FROM ubuntu:latest
-
-${PROXY}
-
-ENV DEBIAN_FRONTEND noninteractive
-RUN apt-get update && apt-get install -yy \
- bc \
- build-essential \
- git \
- gcc-powerpc64le-linux-gnu \
- software-properties-common \
- libssl-dev \
- iputils-ping \
- bison \
- flex
-
-RUN apt-add-repository -y multiverse && apt-get update && apt-get install -yy \
- dwarves \
- sparse
-
-RUN grep -q ${GROUPS[0]} /etc/group || groupadd -g ${GROUPS[0]} ${USER}
-RUN grep -q ${UID} /etc/passwd || useradd -d ${HOME} -m -u ${UID} -g ${GROUPS[0]} ${USER}
-
-USER ${USER}
-ENV HOME ${HOME}
-RUN /bin/bash
-EOF
-)
-
-# Build the docker container
-if ! docker build -t trace-linux-build/ubuntu - <<< "${Dockerfile}" ; then
- echo "Failed to build docker container."
- exit 1
-fi
-
-# Create the docker run script
-export PROXY_HOST=${http_proxy/#http*:\/\/}
-export PROXY_HOST=${PROXY_HOST/%:[0-9]*}
-export PROXY_PORT=${http_proxy/#http*:\/\/*:}
-
-mkdir -p "${WORKSPACE}"
-
-cat > "${WORKSPACE}"/build.sh << EOF_SCRIPT
-#!/bin/bash
-
-set -xe
-
-cd ${WORKSPACE}
-
-# Go into the linux directory (the script will put us in a build subdir)
-cd linux
-
-# Record the version in the logs
-powerpc64le-linux-gnu-gcc --version
-
-# Build kernel prep
-ARCH=powerpc CROSS_COMPILE=powerpc64le-linux-gnu- make mrproper
-
-# Generate the config
-echo "CONFIG_PPC_PSERIES=y" >> fragment.config
-echo "CONFIG_PPC_POWERNV=y" >> fragment.config
-echo "CONFIG_MTD=y" >> fragment.config
-echo "CONFIG_MTD_BLOCK=y" >> fragment.config
-echo "CONFIG_MTD_POWERNV_FLASH=y" >> fragment.config
-ARCH=powerpc scripts/kconfig/merge_config.sh \
- arch/powerpc/configs/ppc64_defconfig \
- arch/powerpc/configs/le.config \
- fragment.config
-
-# Ensure config is up to date and no questions will be asked
-yes "" | ARCH=powerpc CROSS_COMPILE=powerpc64le-linux-gnu- make oldconfig
-
-# Build kernel
-ARCH=powerpc CROSS_COMPILE=powerpc64le-linux-gnu- make -j$(nproc) vmlinux
-
-EOF_SCRIPT
-
-chmod a+x "${WORKSPACE}"/build.sh
-
-# Run the docker container, execute the build script we just built
-docker run --cap-add=sys_admin --net=host --rm=true -e WORKSPACE="${WORKSPACE}" --user="${USER}" \
- -w "${WORKSPACE}" -v "${WORKSPACE}":"${WORKSPACE}" \
- -t trace-linux-build/ubuntu "${WORKSPACE}"/build.sh
-
-result=${?}
-
-# Timestamp for build
-echo "Build completed, $(date)"
-
-exit ${result}
diff --git a/u-boot-build.sh b/u-boot-build.sh
deleted file mode 100755
index b8917a0..0000000
--- a/u-boot-build.sh
+++ /dev/null
@@ -1,74 +0,0 @@
-#!/bin/bash
-
-# This build script is for running the Jenkins builds using docker.
-
-# Trace bash processing
-set -x
-
-# Default variables
-WORKSPACE=${WORKSPACE:-${HOME}/${RANDOM}${RANDOM}}
-BOARD_DEFCONFIG=${BOARD_DEFCONFIG:-ast_g5_defconfig}
-http_proxy=${http_proxy:-}
-
-# Timestamp for job
-echo "Build started, $(date)"
-
-# Configure docker build
-if [[ -n "${http_proxy}" ]]; then
- PROXY="RUN echo \"Acquire::http::Proxy \\"\"${http_proxy}/\\"\";\" > /etc/apt/apt.conf.d/000apt-cacher-ng-proxy"
-fi
-
-Dockerfile=$(cat << EOF
-FROM ubuntu:16.04
-
-${PROXY}
-
-ENV DEBIAN_FRONTEND noninteractive
-RUN apt-get update && apt-get install -yy \
- make bc gcc gcc-arm-linux-gnueabi
-
-RUN grep -q ${GROUPS[0]} /etc/group || groupadd -g ${GROUPS[0]} ${USER}
-RUN grep -q ${UID} /etc/passwd || useradd -d ${HOME} -m -u ${UID} -g ${GROUPS[0]} ${USER}
-
-USER ${USER}
-ENV HOME ${HOME}
-RUN /bin/bash
-EOF
-)
-
-# Build the docker container
-if ! docker build -t u-boot-build/ubuntu - <<< "${Dockerfile}" ; then
- echo "Failed to build docker container."
- exit 1
-fi
-
-# Create the docker run script
-export PROXY_HOST=${http_proxy/#http*:\/\/}
-export PROXY_HOST=${PROXY_HOST/%:[0-9]*}
-export PROXY_PORT=${http_proxy/#http*:\/\/*:}
-
-mkdir -p "${WORKSPACE}"
-
-cat > "${WORKSPACE}"/build.sh << EOF_SCRIPT
-#!/bin/bash
-
-set -x
-
-cd "${WORKSPACE}"
-
-gcc --version
-arm-linux-gnueabi-gcc --version
-
-# Go into the source directory (the script will put us in a build subdir)
-cd u-boot
-CROSS_COMPILE=arm-linux-gnueabi- make ${BOARD_DEFCONFIG}
-CROSS_COMPILE=arm-linux-gnueabi- make
-
-EOF_SCRIPT
-
-chmod a+x "${WORKSPACE}"/build.sh
-
-# Run the docker container, execute the build script we just built
-docker run --rm=true -e WORKSPACE="${WORKSPACE}" --user="${USER}" \
- -w "${HOME}" -v "${HOME}":"${HOME}" -t u-boot-build/ubuntu \
- "${WORKSPACE}"/build.sh