github/open-cas-linux
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
6bb4dde213
open-cas-linux/utils/pckgen
Rafal Stefanowski 7335b321ea Add package generator script 
- add a 'pckgen' script to generate various OpenCAS packages like
release archives (tar, zip), RPMs (source and binary) as well as to
create version file with metadata
- add a SPEC file for RPM creation
- add Makefile targets to use 'pckgen' script through 'make <package>'

'pckgen' script has a bunch of features for package generation.
Read './pckgen --help' for more information on usage scenarios.

Script is also prepared to easily add new packages creation in the future.

Signed-off-by: Rafal Stefanowski <rafal.stefanowski@intel.com>
2020-03-20 03:16:56 +01:00

469 lines
14 KiB
Bash
Executable File
Raw Blame History

#!/bin/bash
#
# Copyright(c) 2020 Intel Corporation
# SPDX-License-Identifier: BSD-3-Clause-Clear
#
# To make additional packages creation possible
# through this script all you need to do is:
# - add 'case' command to set variable 'GENERATE_<NAME>=1'
# - add function 'generate_<name>' to handle the task
# - add 'DEPENDENCIES_<NAME>' array if needed
# - update help!
NAME="open-cas-linux"
SUPPORTED_FROM_VERSION="20.3"
THIS="$(basename $0)"
ARCH="$(uname -i)"
SCRIPT_BASE_DIR="$(dirname $(realpath $0))"
BASE_SPEC="$SCRIPT_BASE_DIR/$NAME.spec.base"
TEMP_TEMPLATE="opencas-${THIS}"
DEPENDENCIES=(sed git)
# Dependencies for particular packages creation:
DEPENDENCIES_TAR=(tar)
DEPENDENCIES_ZIP=(zip)
DEPENDENCIES_RPM=(tar rpmbuild)
DEPENDENCIES_SRPM=("${DEPENDENCIES_RPM[@]}")
# List of relative submodule directories:
SUBMODULES=(
"ocf"
"test/functional/test-framework"
)
usage() {
echo "Usage:"
echo " ./$THIS <commands> [options] <SOURCES_PATH>"
echo " ./$THIS -c|-h"
echo "where SOURCES_PATH is the root directory of OpenCAS sources"
}
print_help() {
echo "Generate OpenCAS packages."
echo "$(usage)"
echo
echo "This script generates various OpenCAS packages like release archives (tar, zip),"
echo "RPMs (source and binary) as well as creates version file with metadata."
echo
echo "Mandatory arguments to long options are mandatory for short options too."
echo
echo "Commands:"
echo " tar generate tar archive"
echo " zip generate zip archive"
echo " rpm generate RPM packages"
echo " srpm generate SRPM package"
echo " version-only create only version file and exit;"
echo
echo "Options:"
echo " -o, --output-dir <DIR> put all created files in the given directory;"
echo " by default all files (except version file)"
echo " will be put in 'SOURCES_PATH/packages/'"
echo " -d, --debug create all debug files and packages as well"
echo " -c, --clean clean all temporary files and folders that"
echo " may have been left around if $THIS ended"
echo " unexpectedly in the previous run"
echo " -h, --help print this help message"
echo
}
invalid_usage() {
>&2 echo -e "$THIS: $*\nTry './$THIS --help' for more information."
exit 2
}
info() {
echo -e "\e[33m$*\e[0m"
}
success() {
echo -e "\n\e[32m=== ALL DONE ===\e[0m\n\nYou can find your fresh packages in '$OUTPUT_DIR'\n"
}
error() {
>&2 echo -e "\e[31mERROR\e[0m: $THIS: $*"
exit 1
}
clean() {
rm -rf "$TEMP_DIR"
if [ -d "$TEMP_DIR" ]; then
# Print only warning to not confuse the user by an error here
# if packages were created successfully and everything else
# went fine except cleaning temp directory at the end.
info "WARNING: Cleanup failed"
fi
}
clean_all() {
info "Removing all temp files and dirs that may have been left around..."
rm -rf /tmp/${TEMP_TEMPLATE}.*
if [[ $(ls -A /tmp/${TEMP_TEMPLATE}.* 2>/dev/null) ]]; then
# This function on the other hand is called only by a '-c' option
# so we may throw an error here and exit.
error "Cleanup failed"
fi
}
check_options() {
if [ ! "$SOURCES_DIR" ]; then
invalid_usage "No mandatory SOURCES_PATH provided"
elif [[ $(head -n 1 "$SOURCES_DIR/README.md" 2> /dev/null) != *Open*CAS*Linux* ]]; then
invalid_usage "'$SOURCES_DIR' does not point to the root directory of CAS sources"
elif [ ! "${!GENERATE_*}" ] && [ ! $VERSION_ONLY ]; then
invalid_usage "Nothing to do - no command provided"
fi
}
check_version() {
cd "$TEMP_DIR"
sh "$CAS_VERSION_GEN" > /dev/null
if [ ! -f "$CAS_VERSION_GEN_FILE" ]; then
error "Couldn't create CAS_VERSION file"
fi
while read -r line; do
case "$line" in
CAS_VERSION_MAIN*) CAS_VERSION_MAIN="${line##*=}";;
CAS_VERSION_MAJOR*) CAS_VERSION_MAJOR="${line##*=}";;
CAS_VERSION_MINOR*) CAS_VERSION_MINOR="${line##*=}";;
esac
done < "$CAS_VERSION_GEN_FILE"
rm "$CAS_VERSION_GEN_FILE"
cd - > /dev/null
VERSION_SHORT="${CAS_VERSION_MAIN}.${CAS_VERSION_MAJOR}"
if [ $CAS_VERSION_MINOR -ne 0 ]; then
VERSION_SHORT+=".${CAS_VERSION_MINOR}"
fi
if [[ "$VERSION_SHORT" < "$SUPPORTED_FROM_VERSION" ]]; then
echo "Sorry... this version of $NAME ($VERSION_SHORT) is not supported"\
"by $THIS. Use $NAME >= $SUPPORTED_FROM_VERSION"
exit 1
fi
for SUBMOD in ${SUBMODULES[@]}; do
if [[ ! $(ls -A "$SOURCES_DIR/$SUBMOD") ]]; then
local SUBMODULES_MISSING+="'$SUBMOD'\n"
fi
done
if [ "$SUBMODULES_MISSING" ]; then
error "There are missing submodules:\n${SUBMODULES_MISSING}\nUpdate submodules and try again!"
fi
if [ -d "$SOURCES_DIR/.git" ]; then
CAS_VERSION_BUILD=$(printf %04d $(git -C "$SOURCES_DIR" log --merges --oneline | wc -l))
LAST_COMMIT_HASH=$(git -C "$SOURCES_DIR" log -1 --pretty=format:%H)
LAST_COMMIT_HASH_ABBR=$(git -C "$SOURCES_DIR" log -1 --pretty=format:%h)
LAST_COMMIT_DATE=$(git -C "$SOURCES_DIR" log -1 --pretty=format:%ci |\
sed "s/ /T/" | sed "s/ //" | sed "s/00$/:00/")
LAST_COMMIT_TIMESTAMP=$(git -C "$SOURCES_DIR" log -1 --pretty=format:%ct)
for SUBMOD in ${SUBMODULES[@]}; do
LAST_SUB_COMMIT_HASHES+=($(git -C "$SOURCES_DIR/$SUBMOD" log -1 --pretty=format:%H))
LAST_SUB_COMMIT_HASHES_ABBR+=($(git -C "$SOURCES_DIR/$SUBMOD" log -1 --pretty=format:%h))
done
elif [ -f "$VERSION_FILE" ]; then
source "$VERSION_FILE" &> /dev/null
else
error "Couldn't obtain CAS version - no git tree nor version file within given sources"
fi
VERSION="${CAS_VERSION_MAIN}.${CAS_VERSION_MAJOR}.${CAS_VERSION_MINOR}.${CAS_VERSION_BUILD}"
if [ $(git -C "$SOURCES_DIR" tag --points-at HEAD) ]; then
RELEASE="release"
elif [ $(git -C "$SOURCES_DIR" log -1 --pretty=format:%H)\
== $(git -C "$SOURCES_DIR" log -1 --merges --pretty=format:%H) ]; then
RELEASE="master"
else
RELEASE="devel.${LAST_COMMIT_TIMESTAMP}"
fi
}
check_dependencies() {
echo "--- Checking for dependencies"
for package in ${!GENERATE_*}; do
local DEP_NAME="DEPENDENCIES_${package##*_}[@]"
DEPENDENCIES+=(${!DEP_NAME})
done
for DEP in ${DEPENDENCIES[@]}; do
which $DEP &> /dev/null
if [ $? -ne 0 ]; then
local FAILED_DEPS+="$DEP "
fi
done
if [ "$FAILED_DEPS" ]; then
error "Dependencies not installed. You need to provide these programs first: $FAILED_DEPS"
fi
}
create_dir() {
mkdir -p "$*"
if [ ! -d "$*" ] || [ ! -w "$*" ]; then
error "No access to '$*'"
fi
}
create_temp() {
TEMP_DIR=$(mktemp -d -t ${TEMP_TEMPLATE}.XXXXXXXXXX)
if [ $? -ne 0 ]; then
error "Couldn't create temporary directory"
fi
}
create_version_file() {
echo "--- Creating version file"
mkdir -p $(dirname "$VERSION_FILE")
touch "$VERSION_FILE"
if [ $? -ne 0 ]; then
error "Couldn't create version file"
fi
CREATION_DATE=$(date --iso-8601=seconds)
CREATION_TIMESTAMP=$(date +%s)
echo "CREATION_DATE=$CREATION_DATE" > "$VERSION_FILE"
echo "CREATION_TIMESTAMP=$CREATION_TIMESTAMP" >> "$VERSION_FILE"
echo "CAS_VERSION_MAIN=$CAS_VERSION_MAIN" >> "$VERSION_FILE"
echo "CAS_VERSION_MAJOR=$CAS_VERSION_MAJOR" >> "$VERSION_FILE"
echo "CAS_VERSION_MINOR=$CAS_VERSION_MINOR" >> "$VERSION_FILE"
echo "CAS_VERSION_BUILD=$CAS_VERSION_BUILD" >> "$VERSION_FILE"
echo "LAST_COMMIT_HASH=$LAST_COMMIT_HASH" >> "$VERSION_FILE"
echo "LAST_COMMIT_HASH_ABBR=$LAST_COMMIT_HASH_ABBR" >> "$VERSION_FILE"
echo "LAST_COMMIT_DATE=$LAST_COMMIT_DATE" >> "$VERSION_FILE"
echo "LAST_COMMIT_TIMESTAMP=$LAST_COMMIT_TIMESTAMP" >> "$VERSION_FILE"
echo "LAST_SUB_COMMIT_HASHES=(${LAST_SUB_COMMIT_HASHES[@]})" >> "$VERSION_FILE"
echo "LAST_SUB_COMMIT_HASHES_ABBR=(${LAST_SUB_COMMIT_HASHES_ABBR[@]})" >> "$VERSION_FILE"
}
archive_prepare() {
if [ $ARCHIVE_PREPARED ]; then
return 0
fi
echo "--- Copying sources to the working directory"
local TEMP_SOURCES_DIR="$TEMP_DIR/$CAS_FILENAME"
rm -rf "$TEMP_SOURCES_DIR"
mkdir -p "$TEMP_SOURCES_DIR"
rsync -a --exclude="/packages" --exclude=".git*" --exclude=".pep8speaks.yml"\
"$SOURCES_DIR/" "$TEMP_SOURCES_DIR"
ARCHIVE_PREPARED=1
}
generate_tar() {
if [ ! $TAR_CREATED ]; then
archive_prepare
echo "--- Creating tar archive from current sources"
tar -C "$TEMP_DIR" -zcf "$TEMP_DIR/$SOURCES_TAR_NAME" "$CAS_FILENAME"
if [ $? -ne 0 ] || [ ! -f "$TEMP_DIR/$SOURCES_TAR_NAME" ]; then
rm -rf "$TEMP_DIR/$SOURCES_TAR_NAME"
error "Couldn't create tar archive"
fi
TAR_CREATED=1
fi
if [ "$1" != "temp" ]; then
cp "$TEMP_DIR/$SOURCES_TAR_NAME" "$OUTPUT_DIR"
fi
}
generate_zip() {
archive_prepare
echo "--- Creating zip archive from current sources"
(cd "$TEMP_DIR" && zip -qr - "$CAS_FILENAME") > "$OUTPUT_DIR/$SOURCES_ZIP_NAME"
if [ $? -ne 0 ] || [ ! -f "$OUTPUT_DIR/$SOURCES_ZIP_NAME" ]; then
rm -rf "$OUTPUT_DIR/$SOURCES_ZIP_NAME"
error "Couldn't create zip archive"
fi
}
rpm_create_tree() {
echo "--- Creating directory tree for building RPMs"
mkdir -p "$RPM_BUILD_DIR/BUILD" "$RPM_BUILD_DIR/RPMS" "$RPM_BUILD_DIR/SOURCES"\
"$RPM_BUILD_DIR/SPECS" "$RPM_BUILD_DIR/SRPMS"
if [ $? -ne 0 ] || [ ! -w "$RPM_BUILD_DIR" ]; then
error "Couldn't create directory tree for building RPMs"
fi
}
rpm_obtain_sources() {
echo "--- Obtaining CAS sources for RPMs"
generate_tar temp
cp -v "$TEMP_DIR/$SOURCES_TAR_NAME" "$RPM_SOURCES_DIR"
if [ ! -f "$RPM_SOURCES_DIR/$SOURCES_TAR_NAME" ]; then
error "Couldn't obtain $SOURCES_TAR_NAME sources tarball!"
fi
}
rpm_spec_prepare() {
echo "--- Preparing SPEC file"
if [ ! -f "$BASE_SPEC" ]; then
error "SPEC file '$BASE_SPEC' not found"
fi
cp -v "$BASE_SPEC" "$RPM_SPECS_DIR/$NAME.spec"
sed -i "s/<CAS_VERSION>/$VERSION/g" "$RPM_SPECS_DIR/$NAME.spec"
sed -i "s/<RPM_RELEASE>/$RELEASE/g" "$RPM_SPECS_DIR/$NAME.spec"
if [ $DEBUG ]; then
echo "--- Debug RPMs will be built as well"
sed -i "s/%define debug_package %{nil}//g" "$RPM_SPECS_DIR/$NAME.spec"
fi
if [ ! -f "$RPM_SPECS_DIR/$NAME.spec" ]; then
error "Couldn't create a SPEC file"
fi
}
generate_rpm() {
if [ $RPM_BUILT ]; then
return 0
fi
rpm_create_tree
rpm_obtain_sources
rpm_spec_prepare
if [ ! $GENERATE_SRPM ] && [ $GENERATE_RPM ]; then
echo "--- Building binary RPM packages"
(HOME="$TEMP_DIR"; rpmbuild -bb "$RPM_SPECS_DIR/$NAME.spec")
if [ $? -ne 0 ]; then
error "Couldn't create RPM packages"
fi
mv -t "$OUTPUT_DIR" "$RPM_RPMS_DIR/$ARCH"/*
fi
if [ $GENERATE_SRPM ] && [ ! $GENERATE_RPM ]; then
echo "--- Building source SRPM package"
(HOME="$TEMP_DIR"; rpmbuild -bs "$RPM_SPECS_DIR/$NAME.spec")
if [ $? -ne 0 ]; then
error "Couldn't create SRPM package"
fi
mv -t "$OUTPUT_DIR" "$RPM_SRPMS_DIR"/*
fi
if [ $GENERATE_SRPM ] && [ $GENERATE_RPM ]; then
echo "--- Building source and binary RPM packages"
(HOME="$TEMP_DIR"; rpmbuild -ba "$RPM_SPECS_DIR/$NAME.spec")
if [ $? -ne 0 ]; then
error "Couldn't create RPM packages"
fi
mv -t "$OUTPUT_DIR" "$RPM_SRPMS_DIR"/*
mv -t "$OUTPUT_DIR" "$RPM_RPMS_DIR/$ARCH"/*
fi
RPM_BUILT=1
}
generate_srpm() {
generate_rpm
}
if (( ! $# )); then
invalid_usage "no arguments given\n$(usage)\n"
fi
while (( $# )); do
case "$1" in
tar)
GENERATE_TAR=1
;;
zip)
GENERATE_ZIP=1
;;
rpm)
GENERATE_RPM=1
;;
srpm)
GENERATE_SRPM=1
;;
version-only)
VERSION_ONLY=1
;;
--output-dir|-o)
OUTPUT_DIR="$2"
dirname $OUTPUT_DIR &> /dev/null
if [ $? -ne 0 ]; then
invalid_usage "no output directory given after the '--output-dir' option"
fi
shift
;;
--debug|-d)
DEBUG=1
;;
--clean|-c)
clean_all
exit 0
;;
--help|-h)
print_help
exit 0
;;
*)
if [ -d "$1" ]; then
SOURCES_DIR=$(realpath "$1")
else
invalid_usage "option '$1' not recognized"
fi
;;
esac
shift
done
check_options
trap clean EXIT
create_temp
### Variables that relates on arguments passed to this script:
# By default all created packages will be put in:
: ${OUTPUT_DIR:="$SOURCES_DIR/packages"}
# Version file location:
VERSION_FILE="$SOURCES_DIR/.metadata/cas_version"
# RPM building directories:
RPM_BUILD_DIR="$TEMP_DIR/rpmbuild"
RPM_SOURCES_DIR="$RPM_BUILD_DIR/SOURCES"
RPM_SPECS_DIR="$RPM_BUILD_DIR/SPECS"
RPM_RPMS_DIR="$RPM_BUILD_DIR/RPMS"
RPM_SRPMS_DIR="$RPM_BUILD_DIR/SRPMS"
# CAS version generator location and output file name:
CAS_VERSION_GEN="$SOURCES_DIR/modules/CAS_VERSION_GEN"
CAS_VERSION_GEN_FILE="CAS_VERSION"
check_version
# CAS naming convention:
CAS_FILENAME="$NAME-v$VERSION"
# CAS sources archives filenames:
SOURCES_TAR_NAME="$CAS_FILENAME.tar.gz"
SOURCES_ZIP_NAME="$CAS_FILENAME.zip"
#
# Run the package generator script
#
info "\n=== Running OpenCAS '$VERSION-$RELEASE' package generator ===\n"
if [ $VERSION_ONLY ]; then
create_version_file
exit 0
fi
echo -n "Packages that will be built: "
for package in ${!GENERATE_*}; do
echo -en "\e[33m${package##*_}\e[0m "
done
echo -e "\n"
check_dependencies
create_version_file
create_dir "$OUTPUT_DIR"
for package in ${!GENERATE_*}; do
${package,,}
done
success
Reference in New Issue View Git Blame Copy Permalink