pkgs: move obs scripts to its own directory

This repository is growing is due to different projects are living
here, kernel config and patches, obs scripts, kata-deploy, release tools.

Lets move the obs scripts to its own directory.

Fixes: #75

Signed-off-by: Jose Carlos Venegas Munoz <jose.carlos.venegas.munoz@intel.com>
This commit is contained in:
Jose Carlos Venegas Munoz
2018-06-15 13:57:00 -05:00
parent 9858c98a69
commit c07d11c967
70 changed files with 0 additions and 0 deletions

View File

@@ -1,353 +0,0 @@
#!/bin/bash
# This is a helper library for the setup scripts of each package
# in this repository.
source ../versions.txt
PACKAGING_DIR=/var/packaging
LOG_DIR=${PACKAGING_DIR}/build_logs
# OBS Project info
OBS_PROJECT="${OBS_PROJECT:-katacontainers}"
OBS_SUBPROJECT="${OBS_SUBPROJECT:-release}"
# BUILD OPTIONS
BUILD_DISTROS=${BUILD_DISTROS:-Fedora_27 xUbuntu_16.04 CentOS_7}
BUILD_ARCH=${BUILD_ARCH:-}x86_64
COMMIT=false
BRANCH=false
LOCAL_BUILD=false
OBS_PUSH=false
VERBOSE=false
# Used for debian.control files
# Architecture: The architecture specifies which type of hardware this
# package was compiled for.
DEB_ARCH="${DEB_ARCH:-amd64}"
if command -v go; then
export GO_ARCH=$(go env GOARCH)
else
export GO_ARCH=amd64
echo "Go not installed using $GO_ARCH to install go in dockerfile"
fi
function display_help()
{
cat <<-EOL
$SCRIPT_NAME
This script is intended to create Kata Containers 3.X packages for the OBS
(Open Build Service) platform.
Usage:
$SCRIPT_NAME [options]
Options:
-l --local-build Build the runtime locally
-c --commit-id Build with a given commit ID
-b --branch Build with a given branch name
-p --push Push changes to OBS
-a --api-url Especify an OBS API (e.g. custom private OBS)
-r --obs-repository An OBS repository to push the changes.
-w --workdir Directory of a working copy of the OBS runtime repo
-v --verbose Set the -x flag for verbosity
-C --clean Clean the repository
-V --verify Verify the environment
-h --help Display this help message
Usage examples:
$SCRIPT_NAME --local-build --branch staging
$SCRIPT_NAME --commit-id a76f45c --push --api-url http://127.0.0.1
$SCRIPT_NAME --commit-id a76f45c --push --obs-repository home:userx/repository
$SCRIPT_NAME --commit-id a76f45c --push
EOL
exit 1
}
die()
{
msg="$*"
echo >&2 "ERROR: $msg"
exit 1
}
info()
{
msg="$*"
echo "INFO: $msg"
}
function verify()
{
# This function perform some checks in order to make sure
# the script will run flawlessly.
# Make sure this script is called from ./
[ "$SCRIPT_DIR" != "." ] && die "The script must be called from its base dir."
# Verify if osc is installed, exit otherwise.
[ ! -x "$(command -v osc)" ] && die "osc is not installed."
info "OK"
}
function clean()
{
# This function clean generated files
for file in "$@"
do
[ -e $file ] && rm -v $file
done
[ -e ./debian.changelog ] && git checkout ./debian.changelog
[ -e ./release ] && git checkout ./release
echo "Clean done."
}
function get_git_info()
{
AUTHOR=${AUTHOR:-$(git config user.name)}
AUTHOR_EMAIL=${AUTHOR_EMAIL:-$(git config user.email)}
}
function set_versions()
{
local commit_hash="$1"
if [ -n "$OBS_REVISION" ]
then
# Validate input is alphanumeric, commit ID
# If a commit ID is provided, override versions.txt one
if [ -n "$COMMIT" ] && [[ "$OBS_REVISION" =~ ^[a-zA-Z0-9][-a-zA-Z0-9]{0,40}[a-zA-Z0-9]$ ]]; then
hash_tag=$OBS_REVISION
elif [ -n "$BRANCH" ]
then
hash_tag=$commit_hash
fi
else
hash_tag=$commit_hash
fi
short_hashtag="${hash_tag:0:7}"
}
function changelog_update {
d=$(date -R)
cat <<< "$PKG_NAME ($VERSION) stable; urgency=medium
* Update $PKG_NAME $VERSION ${hash_tag:0:7}
-- $AUTHOR <$AUTHOR_EMAIL> $d
" > debian.changelog
# Append, so it can be copied to the OBS repository
GENERATED_FILES+=('debian.changelog')
}
function local_build()
{
[ ! -e $PACKAGING_DIR ] && mkdir $PACKAGING_DIR
[ ! -e $LOG_DIR ] && mkdir $LOG_DIR
pushd $OBS_WORKDIR
BUILD_ARGS=('--local-package' '--no-verify' '--noservice' '--trust-all-projects' '--keep-pkgs=/var/packaging/results')
[ "$OFFLINE" == "true" ] && BUILD_ARGS+=('--offline')
osc service run
for distro in ${BUILD_DISTROS[@]}
do
# If more distros are supported, add here the relevant validations.
if [[ "$distro" =~ ^Fedora.* ]] || [[ "$distro" =~ ^CentOS.* ]]
then
echo "Perform a local build for ${distro}"
osc build ${BUILD_ARGS[@]} \
${distro} $BUILD_ARCH *.spec | tee ${LOG_DIR}/${distro}_${PKG_NAME}_build.log
elif [[ "$distro" =~ ^xUbuntu.* ]]
then
echo "Perform a local build for ${distro}"
osc build ${BUILD_ARGS[@]} \
${distro} $BUILD_ARCH *.dsc | tee ${LOG_DIR}/${distro}_${PKG_NAME}_build.log
fi
done
}
function checkout_repo()
{
local REPO="$1"
if [ -z "$OBS_WORKDIR" ]
then
# If no workdir is provided, use a temporary directory.
temp=$(basename $0)
OBS_WORKDIR=$(mktemp -d -u -t ${temp}.XXXXXXXXXXX) || exit 1
osc $APIURL co $REPO -o $OBS_WORKDIR
fi
mv ${GENERATED_FILES[@]} $OBS_WORKDIR
cp ${STATIC_FILES[@]} $OBS_WORKDIR
}
function obs_push()
{
pushd $OBS_WORKDIR
osc $APIURL addremove
osc $APIURL commit -m "Update ${PKG_NAME} $VERSION: ${hash_tag:0:7}"
popd
}
function cli()
{
OPTS=$(getopt -o abclprwvCVh: --long api-url,branch,commit-id,local-build,push,obs-repository,workdir,verbose,clean,verify,help -- "$@")
while true; do
case "${1}" in
-a | --api-url ) APIURL="$2"; shift 2;;
-b | --branch ) BRANCH="true"; OBS_REVISION="$2"; shift 2;;
-c | --commit-id ) COMMIT="true"; OBS_REVISION="$2"; shift 2;;
-l | --local-build ) LOCAL_BUILD="true"; shift;;
-p | --push ) OBS_PUSH="true"; shift;;
-r | --obs-repository ) PROJECT_REPO="$2"; shift 2;;
-w | --workdir ) OBS_WORKDIR="$2"; shift 2;;
-v | --verbose ) VERBOSE="true"; shift;;
-o | --offline ) OFFLINE="true"; shift;;
-C | --clean ) clean ${GENERATED_FILES[@]}; exit $?;;
-V | --verify ) verify; exit $?;;
-h | --help ) display_help; exit $?;;
-- ) shift; break ;;
* ) break ;;
esac
done
}
function build_pkg()
{
obs_repository="${1}"
[ -z "${obs_repository}" ] && die "${FUNCNAME}: obs repository not provided"
checkout_repo "${obs_repository}"
if [ "$LOCAL_BUILD" == "true" ]; then
info "Local build"
local_build
fi
if [ "$OBS_PUSH" == "true" ]; then
info "Push build to OBS"
obs_push
fi
}
function generate_files () {
directory=$1
replace_list=$2
template_files=$(find $directory -type f -name "*-template")
replace_list+=("deb_arch=$DEB_ARCH")
#find_patches sets $RPM_PATCH_LIST and $RPM_PATCH_LIST
# It also creates debian.series file
find_patches
replace_list+=("RPM_PATCH_LIST=$RPM_PATCH_LIST")
replace_list+=("RPM_APPLY_PATCHES=$RPM_APPLY_PATCHES")
# check replace list
# key=val
for replace in "${replace_list[@]}" ; do
[[ "$replace" = *"="* ]] || die "invalid replace $replace"
local key="${replace%%=*}"
local value="${replace##*=}"
[ -n "$key" ] || die "${replace} key is empty"
[ -n "$value" ] || die "${replace} val is empty"
grep -q "@$key@" $template_files || die "@$key@ not found in any template file"
done
for f in ${template_files}; do
genfile="${f%-template}"
cp "$f" "${genfile}"
info "Generate file ${genfile}"
for replace in "${replace_list[@]}" ; do
[[ "$replace" = *"="* ]] || die "invalid replace $replace"
local key="${replace%%=*}"
local value="${replace##*=}"
export k="@${key}@"
export v="$value"
perl -p -e 's/$ENV{k}/$ENV{v}/g' "${genfile}" > "${genfile}.out"
mv "${genfile}.out" ${genfile}
done
done
}
function pkg_version() {
local project_version="$1"
# Used for
# Release: in spec file
# DebianRevisionNumber in dsc files
local pkg_release="$2"
local commit_id="$3"
[ -n "${project_version}" ] || die "${FUNCNAME}: need version"
[ -n "${pkg_release}" ] || die "${FUNCNAME}: pkg release is needed"
pkg_version="${project_version}"
if [ -n "$commit_id" ]; then
pkg_version+="+git.${commit_id:0:7}"
fi
echo "$pkg_version-${pkg_release}"
}
function get_obs_pkg_release() {
local obs_pkg_name="$1"
local pkg
local repo_dir
local release
pkg=$(basename "${obs_pkg_name}")
repo_dir=$(mktemp -d -u -t "${pkg}.XXXXXXXXXXX")
out=$(osc ${APIURL} -q co "${obs_pkg_name}" -o "${repo_dir}") || die "failed to checkout:$out"
spec_file=$(find "${repo_dir}" -maxdepth 1 -type f -name '*.spec' | head -1)
release=$(grep -oP 'Release:\s+[0-9]+' "${spec_file}" | grep -oP '[0-9]+')
if [ -z "${release}" ]; then
release=$(grep -oP '%define\s+release\s+[0-9]+' "${spec_file}" | grep -oP '[0-9]+')
fi
rm -r "${repo_dir}"
echo "${release}"
}
#find_patches find patches in 'patches' directory.
# sets $RPM_PATCH_LIST and $RPM_PATCH_LIST
# RPM_PATCH_LIST fomat:
# Patch<number>: patch.file
# RPM_APPLY_PATCHES fomat:
# %Patch<number> -p1
# It also creates debian.series file
function find_patches() {
export RPM_PATCH_LIST="#Patches"$'\n'
export RPM_APPLY_PATCHES="#Apply patches"$'\n'
[ ! -d patches ] && info "No patches found" && return
local patches
patches=$(find patches -type f -name '*.patch' -exec basename {} \;)
n="1"
rm -f debian.series
for p in ${patches} ; do
STATIC_FILES+=("patches/$p")
RPM_PATCH_LIST+="Patch00${n}: $p"$'\n'
RPM_APPLY_PATCHES+="%patch00${n} -p1"$'\n'
echo "$p" >> debian.series
((n++))
done
GENERATED_FILES+=(debian.series)
}