378 lines
11 KiB
Bash
Executable File
378 lines
11 KiB
Bash
Executable File
#!/bin/bash
|
|
set -e
|
|
|
|
cd $(dirname $(realpath $0))/..
|
|
|
|
edit_config_files=()
|
|
force=false
|
|
no_package_update=false
|
|
force_package_update=false
|
|
delete_old=false
|
|
|
|
erro(){
|
|
echo -e "\e[31m$*\e[0m"
|
|
}
|
|
info(){
|
|
echo -e "\e[36m$*\e[0m"
|
|
}
|
|
light(){
|
|
echo -e "\e[37m$*\e[0m"
|
|
}
|
|
|
|
usage() {
|
|
echo
|
|
light "Usage: $0 [-pfFUuhD] [-v <VERSION>] [-c <CALLBACK FILE>, ...] [-e <EDIT CONFIG FILE>, ...]"
|
|
echo
|
|
echo " OPTIONS:"
|
|
echo
|
|
info " -v <VERSION>"
|
|
echo " Forces the <VERSION>"
|
|
echo
|
|
info " -f Force"
|
|
echo " Upload without asking to git-packages"
|
|
echo
|
|
info " -F Force all"
|
|
echo " Like '-f -U' Do package-update and upload without asking to git-packages"
|
|
echo " Also deletes ALL previous Version"
|
|
echo
|
|
info " -D Delete previous"
|
|
echo " Deletes ALL previous Version"
|
|
echo
|
|
info " -U Package Update"
|
|
echo " Force Package Update Process without asking"
|
|
echo
|
|
info " -u No Package Update"
|
|
echo " Disables asking for Update and ommits"
|
|
echo
|
|
info " -e <EDIT CONFIG FILE>"
|
|
echo " These files may be edited before ./bin/package-update"
|
|
echo " Multiple are possible"
|
|
erro " If ./bin/package-update.d/configs exists, the files in this file are edited (too)"
|
|
echo
|
|
info " -h Help"
|
|
echo " Print this help and exit"
|
|
}
|
|
|
|
while getopts "uUDhfFv:e:" opt; do
|
|
case ${opt} in
|
|
u)
|
|
no_package_update=true
|
|
;;
|
|
U)
|
|
force_package_update=true
|
|
;;
|
|
h)
|
|
usage
|
|
exit 0
|
|
;;
|
|
e)
|
|
edit_config_files+=("$OPTARG")
|
|
;;
|
|
f)
|
|
force=true
|
|
;;
|
|
F)
|
|
force=true
|
|
force_package_update=true
|
|
delete_old=true
|
|
;;
|
|
v)
|
|
version="$OPTARG"
|
|
;;
|
|
D)
|
|
delete_old=true
|
|
;;
|
|
\?)
|
|
usage
|
|
exit 1
|
|
;;
|
|
esac
|
|
done
|
|
|
|
$no_package_update && $force_package_update && ( force_package_update=false; no_package_update=false )
|
|
|
|
|
|
|
|
[[ ! -f apt.conf.sh ]] && echo "No apt.conf.sh in $(pwd) - aborting" && exit 1
|
|
[[ ! -d .git ]] && echo "No .git - aborting" && exit 1
|
|
|
|
if [[ ! -z "$(git status -s)" ]]; then
|
|
echo -e "\e[3;31mCommitte bitte erst die Änderungen\e[0m"
|
|
git status -s
|
|
exit 1
|
|
fi
|
|
|
|
git fetch --tags
|
|
git pull --all
|
|
|
|
|
|
|
|
. apt.conf.sh
|
|
|
|
# from apt.conf.sh:
|
|
[[ -z "$PACKAGE_NAME" ]] && echo "Must have 'PACKAGE_NAME=...' in apt.conf" && exit 2
|
|
[[ -z "$INSTALLDIR" ]] && echo "Must have 'INSTALLDIR=...' in apt.conf" && exit 2
|
|
[[ ! "$INSTALLDIR" =~ ^/ ]] && echo "$INSTALLDIR be absolute" && exit 2
|
|
[[ -z "$DESCRIPTION" ]] && echo "Must have 'DESCRIPTION=...' in apt.conf" && exit 2
|
|
|
|
[[ -f version-affix.txt ]] && PACKAGE_NAME+="-$(cat version-affix.txt)"
|
|
|
|
|
|
REPO_NAME='stable'
|
|
MAIN_VERSION=""
|
|
temp_changelog="/tmp/changelog-$PACKAGE_NAME.txt"
|
|
temp_packageupdate="/tmp/packageupdate-$PACKAGE_NAME.log"
|
|
|
|
[[ -f main-version.txt ]] && MAIN_VERSION=$(cat main-version.txt)
|
|
|
|
branch=$(git branch -q | grep '*' | sed 's/\* *//')
|
|
|
|
# Das erlaubt uns zB ein Odoo 18.0 zu packen (18.0 ist dann main)
|
|
if [[ "$branch" != 'main' ]] && [[ "$branch" != "$MAIN_VERSION" ]]; then
|
|
echo -e "\e[3;31mDu bist nicht auf \e[1;29mmain \e[3;31m - nach \e[1;29mtesting \e[3;31m deployen?"
|
|
read -p "Bitte eingeben [N,y]: " ok
|
|
[[ "$ok" =~ y|Y ]] || echo "Steige aus" && exit 0
|
|
REPO_NAME='testing'
|
|
echo "Die Funktion gibt es noch nicht - es kann nur main oder MAIN_VERSION gepackt werden :(" && exit
|
|
fi
|
|
|
|
# we have to do the update process here because it may change the main-version.txt
|
|
PACKAGE_UPDATE=$force_package_update
|
|
if $no_package_update; then
|
|
PACKAGE_UPDATE=false
|
|
elif ! $force_package_update; then
|
|
if [[ -f bin/package-update ]]; then
|
|
read -p "Soll ein package-update gemacht werden? [N,y]: " _PU
|
|
[[ "$_PU" =~ y|Y ]] && PACKAGE_UPDATE=true
|
|
fi
|
|
fi
|
|
|
|
if $PACKAGE_UPDATE; then
|
|
if [[ -f bin/package-update.d/configs ]]; then
|
|
info "Edit configfiles in package-update.d/configs"
|
|
while read cfgf; do
|
|
[[ ! -f "$cfgf" ]] && erro "$cfgf does not exist" && continue
|
|
read -p "Edit $cfgf? [N,y]: " _edok
|
|
[[ "$_edok" =~ y|Y ]] || continue
|
|
vi $cfgf
|
|
git add $cfgf
|
|
while [[ -z "$commit_msg" ]]; do
|
|
read -p $(info "Commit Message: ") commit_msg
|
|
done
|
|
git commit -m "$commit_msg"
|
|
done < bin/package-update.d/configs
|
|
fi
|
|
if [[ ! -z "$edit_config_files" ]]; then
|
|
info "Edit configfiles from params (-e)"
|
|
for cfgf in "${edit_config_files[@]}"; do
|
|
[[ ! -f "$cfgf" ]] && erro "$cfgf does not exist" && continue
|
|
vi $cfgf
|
|
git add $cfgf
|
|
while [[ -z "$commit_msg" ]]; do
|
|
read -p $(info "Commit Message: ") commit_msg
|
|
done
|
|
git commit -m "$commit_msg"
|
|
done
|
|
fi
|
|
|
|
./bin/package-update 2>&1 | tee -a $temp_packageupdate
|
|
|
|
if [[ "${PIPESTATUS[0]}" != "0" ]]; then
|
|
read -p "Das ging irgendwie schief (s. Ausgabe) - trotzdem packen? [N,y]: " proceed
|
|
[[ "$proceed" =~ y|Y ]] || error "Steige aus" && exit 16
|
|
fi
|
|
fi
|
|
|
|
|
|
ARCHITECTURE="all"
|
|
get_version() {
|
|
[[ ! -z "$version" ]] && echo -n "" && return 0
|
|
git tag | grep -Pe '^build-' | sort -V | tail -1 | sed 's/^build-//'
|
|
}
|
|
VERSION=$(get_version)
|
|
|
|
if [[ -z $VERSION ]]; then
|
|
VERSION=${version-0.0.1}
|
|
[[ ! -z "$MAIN_VERSION" ]] && VERSION="${MAIN_VERSION}-${VERSION}"
|
|
update=0
|
|
else
|
|
# get "real" version without main version
|
|
_update=1
|
|
if [[ "$VERSION" =~ - ]]; then
|
|
_MAIN_VERSION=$(echo $VERSION | perl -pe 's/^([^\-]+)-.*/\1/')
|
|
VERSION=$(echo $VERSION | perl -pe 's/^[^\-]+-(\d+\.\d+\.\d+).*/\1/')
|
|
if [[ ! -z "$MAIN_VERSION" ]]; then
|
|
_HIGHER_VERSION=$((echo "$_MAIN_VERSION" && echo "$MAIN_VERSION") | sort -V | tail -1)
|
|
[[ "$_HIGHER_VERSION" != "$MAIN_VERSION" ]] && echo "Main version aus file ist kleiner als die aus den tags ($MAIN_VERSION < $_MAIN_VERSION)" && exit 2
|
|
if [[ "$_MAIN_VERSION" != "$MAIN_VERSION" ]]; then
|
|
# Upgrade Main Version
|
|
VERSION="${MAIN_VERSION}-0.0.1"
|
|
_update=0
|
|
fi
|
|
fi
|
|
fi
|
|
update=$_update
|
|
fi
|
|
|
|
if [ $update -eq 1 ]; then
|
|
echo "Welche Art von Update?"
|
|
echo "1) Major (x.0.0) - Für große Änderungen"
|
|
echo "2) Minor (0.x.0) - Für neue Features"
|
|
echo "3) Patch (0.0.x) - Für Bugfixes"
|
|
read -p "Wähle (1-3): " update_type
|
|
|
|
IFS='.' read -r -a version_parts <<< "$VERSION"
|
|
major="${version_parts[0]}"
|
|
minor="${version_parts[1]}"
|
|
patch="${version_parts[2]}"
|
|
|
|
[[ -z "$update_type" ]] && update_type=3
|
|
|
|
case $update_type in
|
|
1) # major
|
|
major=$((major + 1))
|
|
minor=0
|
|
patch=0
|
|
;;
|
|
2) # minor
|
|
minor=$((minor + 1))
|
|
patch=0
|
|
;;
|
|
3) # patch
|
|
patch=$((patch + 1))
|
|
;;
|
|
esac
|
|
|
|
NEW_VERSION="${major}.${minor}.${patch}"
|
|
[[ -z $MAIN_VERSION ]] || NEW_VERSION="${MAIN_VERSION}-${NEW_VERSION}"
|
|
else
|
|
NEW_VERSION=$VERSION
|
|
fi
|
|
|
|
relevant=()
|
|
|
|
while IFS= read -r line; do
|
|
if [[ "$line" =~ build- ]]; then
|
|
echo -e "\e[1;31m$line\e[0m" 1>&2
|
|
break
|
|
fi
|
|
relevant+=("$line") # Füge die relevante Zeile zum Array hinzu
|
|
done < <(git log --oneline --decorate)
|
|
|
|
echo "$PACKAGE_NAME ($NEW_VERSION) stable; urgency=medium" > $temp_changelog
|
|
echo "----------------------------------------------------------------------" >> $temp_changelog
|
|
for line in "${relevant[@]}"; do
|
|
echo -e "* $line\n" >> $temp_changelog
|
|
done
|
|
echo >> $temp_changelog
|
|
if grep -qi 'extracting archive' $temp_packageupdate ; then
|
|
grep -i "extracting archive" $temp_packageupdate | sed 's/extracting archive *//' >> $temp_changelog
|
|
echo >> $temp_changelog
|
|
fi
|
|
echo >> $temp_changelog
|
|
echo "-- $(git config user.name) <$(git config user.email)> $(date -R)" >> $temp_changelog
|
|
echo "----------------------------------------------------------------------" >> $temp_changelog
|
|
|
|
cat debian/changelog >> $temp_changelog
|
|
|
|
BUILD_DIR="build"
|
|
rm -rf $BUILDDIR
|
|
DEBIAN_DIR="${BUILD_DIR}/DEBIAN"
|
|
INSTALL_DIR="${BUILD_DIR}${INSTALLDIR}"
|
|
|
|
mkdir -p "${DEBIAN_DIR}"
|
|
mkdir -p "${INSTALL_DIR}"
|
|
|
|
CONTROLFILE="${DEBIAN_DIR}/control"
|
|
|
|
cat > $CONTROLFILE << EOF
|
|
Package: ${PACKAGE_NAME}
|
|
Version: ${NEW_VERSION}
|
|
Section: web
|
|
Priority: optional
|
|
Architecture: ${ARCHITECTURE}
|
|
Pre-Depends: $DEPENDENCIES
|
|
EOF
|
|
if [[ ! -z "$SUGGESTS" ]]; then
|
|
echo "Suggests: $SUGGESTS" >> $CONTROLFILE
|
|
fi
|
|
cat >> $CONTROLFILE << EOF
|
|
Maintainer: $(git config user.name) <$(git config user.email)>
|
|
Description: $DESCRIPTION
|
|
EOF
|
|
|
|
|
|
for inst_script in preinst conffiles; do
|
|
[[ ! -f debscripts/$inst_script ]] && echo "No $inst_script - continue" 1>&2 && continue
|
|
cp debscripts/$inst_script $DEBIAN_DIR
|
|
chmod 755 $DEBIAN_DIR/$inst_script
|
|
done
|
|
postinst=debscripts/postinst
|
|
POSTINST=$DEBIAN_DIR/postinst
|
|
|
|
echo "Create postinst"
|
|
echo '#!/bin/bash' > $POSTINST
|
|
find src/ -type f -path '*/etc/sudoers.d/*' -exec bash -c 'fn={};echo chown -v root:root ${fn/src/}' \; >> $POSTINST
|
|
find src/ -type f -path '*/etc/sudoers.d/*' -exec bash -c 'fn={};echo chmod -v 440 ${fn/src/}' \; >> $POSTINST
|
|
find src/ -type f -path '*/etc/cron.*/*' -exec bash -c 'fn={};echo chmod -v 700 ${fn/src/};' \; >> $POSTINST
|
|
|
|
if [[ -f $postinst ]]; then
|
|
if head -n 1 $postinst | grep -q 'bash'; then
|
|
echo "Extend postinst"
|
|
cat $postinst >> $POSTINST
|
|
else
|
|
echo "no bash script - taking original"
|
|
cat $postinst > $POSTINST
|
|
fi
|
|
fi
|
|
chmod 755 $POSTINST
|
|
|
|
[[ -f debscripts/before-copy ]] && . debscripts/before-copy
|
|
|
|
if [[ -f debscripts/src-to-builddir ]]; then
|
|
. debscripts/src-to-builddir
|
|
else
|
|
rsync -av --exclude .gitignore src/ $INSTALL_DIR
|
|
fi
|
|
|
|
# find $INSTALL_DIR -path '*/etc/sudoers.d*' -type f -exec bash -c "sudo chown root:root {};sudo chmod 400 {};" \;
|
|
|
|
[[ -f debscripts/after-copy ]] && . debscripts/after-copy
|
|
|
|
cp $temp_changelog "${DEBIAN_DIR}/changelog"
|
|
gzip -9 -n "${DEBIAN_DIR}/changelog"
|
|
|
|
distfile="dists/$REPO_NAME/main/binary-amd64/${PACKAGE_NAME}_${NEW_VERSION}_${ARCHITECTURE}.deb"
|
|
mkdir -p "dists/$REPO_NAME/main/binary-amd64"
|
|
|
|
[[ -f debscripts/before-build ]] && . debscripts/before-build
|
|
|
|
dpkg-deb --build "${BUILD_DIR}" $distfile
|
|
# ME=$(whoami)
|
|
# sudo chown -R $ME:$ME $distfile $BUILD_DIR
|
|
|
|
[[ -f debscripts/after-build ]] && . debscripts/after-build
|
|
|
|
echo "Paket wurde erstellt: $distfile"
|
|
|
|
rm -rf "${BUILD_DIR}"
|
|
|
|
if [[ -z $DEBBUILD_ASSUME_YES ]] && ! $force; then
|
|
read -p "Hochladen? [Y,n]: " upload
|
|
[[ "$upload" =~ n|N ]] && exit 0
|
|
fi
|
|
|
|
[[ -f debscripts/before-deploy ]] && . debscripts/before-deploy
|
|
|
|
. $(dirname $0)/deploy-package
|
|
|
|
[[ -f debscripts/after-deploy ]] && . debscripts/after-deploy
|
|
|
|
echo "$NEW_VERSION" > version.txt
|
|
mv $temp_changelog debian/changelog
|
|
git add version.txt debian/changelog
|
|
git commit -m "Deploy $NEW_VERSION"
|
|
git tag -a "build-$NEW_VERSION" -m "Deploy builded $NEW_VERSION"
|
|
git push
|
|
git push --tags
|