yudaike/openSUSE-release-tools
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
openSUSE-release-tools/gocd/slfo-stagings.gocd.yaml

2177 lines
86 KiB
YAML
Raw Normal View History

gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
---
format_version: 3
pipelines:
gocd: slfo-stagings: Freeze the Stagings each Sunday. Stagings will be frozen iif: - Check.Ring.1.Built job succeeds (runs every hour on Sundays, from 0 to 23. simple check and then exit) - If the former check is successful, and it has not been freezed in the past day
2024-08-26 14:43:14 +02:00
SUSE.SLFO.Main.Staging.Weekly.Freeze:
environment_variables:
SLFO_PROJECT: SUSE:SLFO:Main
SLFO_RING_1_PROJECT: SUSE:SLFO:Main:Staging:Rings:1-MinimalX
STAGING_API: https://api.suse.de
gocd: SUSE.SLFO.Main.Staging.Weekly.Freeze: Add osc staging bot oscrc.
2024-09-04 17:11:32 +02:00
OSC_CONFIG: /home/go/config/oscrc-staging-bot
gocd: slfo-stagings: Freeze the Stagings each Sunday. Stagings will be frozen iif: - Check.Ring.1.Built job succeeds (runs every hour on Sundays, from 0 to 23. simple check and then exit) - If the former check is successful, and it has not been freezed in the past day
2024-08-26 14:43:14 +02:00
group: SLFO.Stagings
lock_behavior: unlockWhenFinished
timer:
gocd: slfo-stagins: Minor syntax hot fix.
2024-08-30 10:09:47 +02:00
spec: "0 0 0-23 ? * SUN"
gocd: slfo-stagings: Freeze the Stagings each Sunday. Stagings will be frozen iif: - Check.Ring.1.Built job succeeds (runs every hour on Sundays, from 0 to 23. simple check and then exit) - If the former check is successful, and it has not been freezed in the past day
2024-08-26 14:43:14 +02:00
materials:
scripts:
auto_update: true
git: https://github.com/openSUSE/openSUSE-release-tools.git
whitelist:
- DO_NOT_TRIGGER
stages:
- Check.Ring.1.Finished:
timeout: 50
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: Avoid busy waiting for 50 minutes, instead rely on scheduling from GoCD.
2024-09-04 15:45:24 +02:00
set -eu
status="$(osc -A $STAGING_API api /build/$SLFO_RING_1_PROJECT/standard/x86_64?view=status | grep 'code=' | sed -E 's/^.*code="(.*)".*$/\1/')"
echo $SLFO_RING_1_PROJECT status: "${status}"
gocd: slfo-stagings: Fix syntax error.
2024-09-06 15:47:26 +02:00
if printf '%s' "${status}" | grep -q finished; then
gocd: slfo-stagings: Avoid busy waiting for 50 minutes, instead rely on scheduling from GoCD.
2024-09-04 15:45:24 +02:00
exit 0
else
exit 1
fi
gocd: slfo-stagings: Freeze the Stagings each Sunday. Stagings will be frozen iif: - Check.Ring.1.Built job succeeds (runs every hour on Sundays, from 0 to 23. simple check and then exit) - If the former check is successful, and it has not been freezed in the past day
2024-08-26 14:43:14 +02:00
- Freeze.stagings:
gocd: slfo-stagins: Minor syntax hot fix.
2024-08-30 10:09:47 +02:00
## 6 hours (at most 30 minutes per staging)
gocd: slfo-stagings: Freeze the Stagings each Sunday. Stagings will be frozen iif: - Check.Ring.1.Built job succeeds (runs every hour on Sundays, from 0 to 23. simple check and then exit) - If the former check is successful, and it has not been freezed in the past day
2024-08-26 14:43:14 +02:00
timeout: 360
resources:
- staging-bot
tasks:
- script: |-
set -eu
gocd: slfo_stagings: Fix openSUSE-release-tools path.
2024-09-16 12:08:00 +02:00
export PYTHONPATH=$PWD
gocd: slfo-stagings: Fix osc staging plugin setup.
2024-09-11 13:18:42 +02:00
## Setup osc staging plugin
tempdir=$(mktemp -d)
mkdir -p $tempdir/.osc-plugins
ln -s $PWD/osc-staging.py $tempdir/.osc-plugins
ln -s $PWD/osclib $tempdir/.osc-plugins
export HOME=$tempdir
gocd: slfo-stagings: Freeze the Stagings each Sunday. Stagings will be frozen iif: - Check.Ring.1.Built job succeeds (runs every hour on Sundays, from 0 to 23. simple check and then exit) - If the former check is successful, and it has not been freezed in the past day
2024-08-26 14:43:14 +02:00
for letter in A B C D E F G H S V Y ; do
gocd: slfo-stagins: Minor syntax hot fix.
2024-08-30 10:09:47 +02:00
## if the staging was frozen today, skip it
gocd: slfo-stagings: Freeze the Stagings each Sunday. Stagings will be frozen iif: - Check.Ring.1.Built job succeeds (runs every hour on Sundays, from 0 to 23. simple check and then exit) - If the former check is successful, and it has not been freezed in the past day
2024-08-26 14:43:14 +02:00
if ! osc -A $STAGING_API meta attribute "${SLFO_PROJECT}:Staging:${letter}" --attribute OSRT:FreezeTime | grep $(date +%Y-%m-%d); then
osc -A $STAGING_API staging freeze -p $SLFO_PROJECT $letter
else
gocd: slfo-stagings: Fix osc staging plugin setup.
2024-09-11 13:18:42 +02:00
echo "${SLFO_PROJECT}:Staging:${letter}" was frozen today, skipping it...
gocd: slfo-stagings: Freeze the Stagings each Sunday. Stagings will be frozen iif: - Check.Ring.1.Built job succeeds (runs every hour on Sundays, from 0 to 23. simple check and then exit) - If the former check is successful, and it has not been freezed in the past day
2024-08-26 14:43:14 +02:00
fi
done
gocd: slfo-stagings: Fix osc staging plugin setup.
2024-09-11 13:18:42 +02:00
## Tear down osc staging plugin
rm -rf $tempdir
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
SUSE.SLFO.Main.Staging.A:
environment_variables:
STAGING_PROJECT: SUSE:SLFO:Main:Staging:A
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:Main:Staging:A_-_standard.yaml
scripts:
auto_update: true
Restore SLFO pipelines
2024-06-11 15:44:39 +02:00
git: https://github.com/openSUSE/openSUSE-release-tools.git
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p SUSE:SLFO:Main -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
gocd: Allow SLFO to have pkglists generated.
2024-05-30 10:05:37 +02:00
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
- Build.product:
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
timeout: 180
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
minutes=1
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Let the scheduler warm up first
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
done
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Always fail on broken/failed products
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
SUSE.SLFO.Main.Staging.B:
environment_variables:
STAGING_PROJECT: SUSE:SLFO:Main:Staging:B
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:Main:Staging:B_-_standard.yaml
scripts:
auto_update: true
Restore SLFO pipelines
2024-06-11 15:44:39 +02:00
git: https://github.com/openSUSE/openSUSE-release-tools.git
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p SUSE:SLFO:Main -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
gocd: Allow SLFO to have pkglists generated.
2024-05-30 10:05:37 +02:00
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
- Build.product:
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
timeout: 180
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
minutes=1
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Let the scheduler warm up first
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
done
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Always fail on broken/failed products
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
SUSE.SLFO.Main.Staging.C:
environment_variables:
STAGING_PROJECT: SUSE:SLFO:Main:Staging:C
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:Main:Staging:C_-_standard.yaml
scripts:
auto_update: true
Restore SLFO pipelines
2024-06-11 15:44:39 +02:00
git: https://github.com/openSUSE/openSUSE-release-tools.git
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p SUSE:SLFO:Main -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
gocd: Allow SLFO to have pkglists generated.
2024-05-30 10:05:37 +02:00
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
- Build.product:
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
timeout: 180
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
minutes=1
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Let the scheduler warm up first
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
done
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Always fail on broken/failed products
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
SUSE.SLFO.Main.Staging.D:
environment_variables:
STAGING_PROJECT: SUSE:SLFO:Main:Staging:D
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:Main:Staging:D_-_standard.yaml
scripts:
auto_update: true
Restore SLFO pipelines
2024-06-11 15:44:39 +02:00
git: https://github.com/openSUSE/openSUSE-release-tools.git
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p SUSE:SLFO:Main -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
gocd: Allow SLFO to have pkglists generated.
2024-05-30 10:05:37 +02:00
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
- Build.product:
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
timeout: 180
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
minutes=1
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Let the scheduler warm up first
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
done
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Always fail on broken/failed products
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
SUSE.SLFO.Main.Staging.E:
environment_variables:
STAGING_PROJECT: SUSE:SLFO:Main:Staging:E
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:Main:Staging:E_-_standard.yaml
scripts:
auto_update: true
Restore SLFO pipelines
2024-06-11 15:44:39 +02:00
git: https://github.com/openSUSE/openSUSE-release-tools.git
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p SUSE:SLFO:Main -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
gocd: Allow SLFO to have pkglists generated.
2024-05-30 10:05:37 +02:00
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
- Build.product:
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
timeout: 180
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
minutes=1
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Let the scheduler warm up first
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
done
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Always fail on broken/failed products
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
SUSE.SLFO.Main.Staging.F:
environment_variables:
STAGING_PROJECT: SUSE:SLFO:Main:Staging:F
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:Main:Staging:F_-_standard.yaml
scripts:
auto_update: true
Restore SLFO pipelines
2024-06-11 15:44:39 +02:00
git: https://github.com/openSUSE/openSUSE-release-tools.git
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p SUSE:SLFO:Main -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
gocd: Allow SLFO to have pkglists generated.
2024-05-30 10:05:37 +02:00
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
- Build.product:
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
timeout: 180
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
minutes=1
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Let the scheduler warm up first
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
done
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Always fail on broken/failed products
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
SUSE.SLFO.Main.Staging.G:
environment_variables:
STAGING_PROJECT: SUSE:SLFO:Main:Staging:G
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:Main:Staging:G_-_standard.yaml
scripts:
auto_update: true
Restore SLFO pipelines
2024-06-11 15:44:39 +02:00
git: https://github.com/openSUSE/openSUSE-release-tools.git
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p SUSE:SLFO:Main -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
gocd: Allow SLFO to have pkglists generated.
2024-05-30 10:05:37 +02:00
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
- Build.product:
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
timeout: 180
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
minutes=1
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Let the scheduler warm up first
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
done
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Always fail on broken/failed products
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
SUSE.SLFO.Main.Staging.H:
environment_variables:
STAGING_PROJECT: SUSE:SLFO:Main:Staging:H
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:Main:Staging:H_-_standard.yaml
scripts:
auto_update: true
Restore SLFO pipelines
2024-06-11 15:44:39 +02:00
git: https://github.com/openSUSE/openSUSE-release-tools.git
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p SUSE:SLFO:Main -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
gocd: Allow SLFO to have pkglists generated.
2024-05-30 10:05:37 +02:00
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
- Build.product:
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
timeout: 180
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
minutes=1
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Let the scheduler warm up first
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
done
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Always fail on broken/failed products
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
SUSE.SLFO.Main.Staging.S:
environment_variables:
STAGING_PROJECT: SUSE:SLFO:Main:Staging:S
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:Main:Staging:S_-_standard.yaml
scripts:
auto_update: true
Restore SLFO pipelines
2024-06-11 15:44:39 +02:00
git: https://github.com/openSUSE/openSUSE-release-tools.git
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p SUSE:SLFO:Main -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
gocd: Allow SLFO to have pkglists generated.
2024-05-30 10:05:37 +02:00
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
- Build.product:
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
timeout: 180
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
minutes=1
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Let the scheduler warm up first
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
done
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Always fail on broken/failed products
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
SUSE.SLFO.Main.Staging.V:
environment_variables:
STAGING_PROJECT: SUSE:SLFO:Main:Staging:V
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:Main:Staging:V_-_standard.yaml
scripts:
auto_update: true
Restore SLFO pipelines
2024-06-11 15:44:39 +02:00
git: https://github.com/openSUSE/openSUSE-release-tools.git
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p SUSE:SLFO:Main -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
gocd: Allow SLFO to have pkglists generated.
2024-05-30 10:05:37 +02:00
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
- Build.product:
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
timeout: 180
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
minutes=1
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Let the scheduler warm up first
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
done
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Always fail on broken/failed products
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
SUSE.SLFO.Main.Staging.Y:
environment_variables:
STAGING_PROJECT: SUSE:SLFO:Main:Staging:Y
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:Main:Staging:Y_-_standard.yaml
scripts:
auto_update: true
Restore SLFO pipelines
2024-06-11 15:44:39 +02:00
git: https://github.com/openSUSE/openSUSE-release-tools.git
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p SUSE:SLFO:Main -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
gocd: Allow SLFO to have pkglists generated.
2024-05-30 10:05:37 +02:00
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
- Build.product:
timeout: 180
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
minutes=1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Let the scheduler warm up first
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
fi
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
done
gocd: slfo-stagings: slfo-stagings: fail on broken/failed products (SLFO:Main) Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. This is #3191, but for SUSE:SLFO:Main rather than 1.1. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 15:38:25 +01:00
## Always fail on broken/failed products
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
SUSE.SLFO.1.1.Staging.Weekly.Freeze:
environment_variables:
SLFO_1_1_PROJECT: SUSE:SLFO:1.1
SLFO_1_1_RING_1_PROJECT: SUSE:SLFO:1.1:Staging:Rings:1-MinimalX
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.1.1.Stagings
lock_behavior: unlockWhenFinished
timer:
spec: "0 0 0-23 ? * SUN"
materials:
scripts:
auto_update: true
git: https://github.com/openSUSE/openSUSE-release-tools.git
whitelist:
- DO_NOT_TRIGGER
stages:
- Check.Ring.1.Finished:
timeout: 50
resources:
- staging-bot
tasks:
- script: |-
set -eu
status="$(osc -A $STAGING_API api /build/$SLFO_1_1_RING_1_PROJECT/standard/x86_64?view=status | grep 'code=' | sed -E 's/^.*code="(.*)".*$/\1/')"
echo $SLFO_1_1_RING_1_PROJECT status: "${status}"
if printf '%s' "${status}" | grep -q finished; then
exit 0
else
exit 1
fi
- Freeze.stagings:
## 6 hours (at most 30 minutes per staging)
timeout: 360
resources:
- staging-bot
tasks:
- script: |-
set -eu
export PYTHONPATH=$PWD
## Setup osc staging plugin
tempdir=$(mktemp -d)
mkdir -p $tempdir/.osc-plugins
ln -s $PWD/osc-staging.py $tempdir/.osc-plugins
ln -s $PWD/osclib $tempdir/.osc-plugins
export HOME=$tempdir
for letter in A B C D E F G H S V Y ; do
## if the staging was frozen today, skip it
if ! osc -A $STAGING_API meta attribute "${SLFO_1_1_PROJECT}:Staging:${letter}" --attribute OSRT:FreezeTime | grep $(date +%Y-%m-%d); then
osc -A $STAGING_API staging freeze -p $SLFO_1_1_PROJECT $letter
else
echo "${SLFO_1_1_PROJECT}:Staging:${letter}" was frozen today, skipping it...
fi
done
## Tear down osc staging plugin
rm -rf $tempdir
SUSE.SLFO.1.1.Staging.A:
environment_variables:
SLFO_1_1_PROJECT: SUSE:SLFO:1.1
STAGING_PROJECT: SUSE:SLFO:1.1:Staging:A
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.1.1.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:1.1:Staging:A_-_standard.yaml
scripts:
auto_update: true
git: https://github.com/openSUSE/openSUSE-release-tools.git
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p $SLFO_1_1_PROJECT -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
- Build.product:
timeout: 180
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
minutes=1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Let the scheduler warm up first
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
fi
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
done
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Always fail on broken/failed products
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
SUSE.SLFO.1.1.Staging.B:
environment_variables:
SLFO_1_1_PROJECT: SUSE:SLFO:1.1
STAGING_PROJECT: SUSE:SLFO:1.1:Staging:B
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.1.1.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:1.1:Staging:B_-_standard.yaml
scripts:
auto_update: true
git: https://github.com/openSUSE/openSUSE-release-tools.git
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p $SLFO_1_1_PROJECT -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
- Build.product:
timeout: 180
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
minutes=1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Let the scheduler warm up first
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
fi
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
done
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Always fail on broken/failed products
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
SUSE.SLFO.1.1.Staging.C:
environment_variables:
SLFO_1_1_PROJECT: SUSE:SLFO:1.1
STAGING_PROJECT: SUSE:SLFO:1.1:Staging:C
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.1.1.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:1.1:Staging:C_-_standard.yaml
scripts:
auto_update: true
git: https://github.com/openSUSE/openSUSE-release-tools.git
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p $SLFO_1_1_PROJECT -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
- Build.product:
timeout: 180
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
minutes=1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Let the scheduler warm up first
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
fi
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
done
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Always fail on broken/failed products
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
SUSE.SLFO.1.1.Staging.D:
environment_variables:
SLFO_1_1_PROJECT: SUSE:SLFO:1.1
STAGING_PROJECT: SUSE:SLFO:1.1:Staging:D
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.1.1.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:1.1:Staging:D_-_standard.yaml
scripts:
auto_update: true
git: https://github.com/openSUSE/openSUSE-release-tools.git
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p $SLFO_1_1_PROJECT -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
- Build.product:
timeout: 180
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
minutes=1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Let the scheduler warm up first
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
fi
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
done
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Always fail on broken/failed products
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
SUSE.SLFO.1.1.Staging.E:
environment_variables:
SLFO_1_1_PROJECT: SUSE:SLFO:1.1
STAGING_PROJECT: SUSE:SLFO:1.1:Staging:E
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.1.1.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:1.1:Staging:E_-_standard.yaml
scripts:
auto_update: true
git: https://github.com/openSUSE/openSUSE-release-tools.git
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p $SLFO_1_1_PROJECT -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
- Build.product:
timeout: 180
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
minutes=1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Let the scheduler warm up first
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
fi
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
done
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Always fail on broken/failed products
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
SUSE.SLFO.1.1.Staging.F:
environment_variables:
SLFO_1_1_PROJECT: SUSE:SLFO:1.1
STAGING_PROJECT: SUSE:SLFO:1.1:Staging:F
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.1.1.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:1.1:Staging:F_-_standard.yaml
scripts:
auto_update: true
git: https://github.com/openSUSE/openSUSE-release-tools.git
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p $SLFO_1_1_PROJECT -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
- Build.product:
timeout: 180
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
minutes=1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Let the scheduler warm up first
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
fi
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
done
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Always fail on broken/failed products
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
SUSE.SLFO.1.1.Staging.G:
environment_variables:
SLFO_1_1_PROJECT: SUSE:SLFO:1.1
STAGING_PROJECT: SUSE:SLFO:1.1:Staging:G
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.1.1.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:1.1:Staging:G_-_standard.yaml
scripts:
auto_update: true
git: https://github.com/openSUSE/openSUSE-release-tools.git
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p $SLFO_1_1_PROJECT -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
- Build.product:
timeout: 180
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
minutes=1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Let the scheduler warm up first
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
fi
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
done
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Always fail on broken/failed products
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
SUSE.SLFO.1.1.Staging.H:
environment_variables:
SLFO_1_1_PROJECT: SUSE:SLFO:1.1
STAGING_PROJECT: SUSE:SLFO:1.1:Staging:H
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.1.1.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:1.1:Staging:H_-_standard.yaml
scripts:
auto_update: true
git: https://github.com/openSUSE/openSUSE-release-tools.git
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p $SLFO_1_1_PROJECT -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
- Build.product:
timeout: 180
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
minutes=1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Let the scheduler warm up first
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
fi
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
done
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Always fail on broken/failed products
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
SUSE.SLFO.1.1.Staging.S:
environment_variables:
SLFO_1_1_PROJECT: SUSE:SLFO:1.1
STAGING_PROJECT: SUSE:SLFO:1.1:Staging:S
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.1.1.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:1.1:Staging:S_-_standard.yaml
scripts:
auto_update: true
git: https://github.com/openSUSE/openSUSE-release-tools.git
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p $SLFO_1_1_PROJECT -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
- Build.product:
timeout: 180
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
minutes=1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Let the scheduler warm up first
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
fi
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
done
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Always fail on broken/failed products
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
SUSE.SLFO.1.1.Staging.V:
environment_variables:
SLFO_1_1_PROJECT: SUSE:SLFO:1.1
STAGING_PROJECT: SUSE:SLFO:1.1:Staging:V
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.1.1.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:1.1:Staging:V_-_standard.yaml
scripts:
auto_update: true
git: https://github.com/openSUSE/openSUSE-release-tools.git
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p $SLFO_1_1_PROJECT -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
- Build.product:
timeout: 180
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
minutes=1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Let the scheduler warm up first
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
fi
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
done
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Always fail on broken/failed products
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: Add SUSE:SLFO:1.1 pipelines.
2024-09-16 15:26:25 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
SUSE.SLFO.1.1.Staging.Y:
environment_variables:
SLFO_1_1_PROJECT: SUSE:SLFO:1.1
STAGING_PROJECT: SUSE:SLFO:1.1:Staging:Y
STAGING_API: https://api.suse.de
OSC_CONFIG: /home/go/config/oscrc-staging-bot
group: SLFO.1.1.Stagings
lock_behavior: unlockWhenFinished
materials:
stagings:
git: git://botmaster.suse.de/suse-repos.git
auto_update: true
destination: repos
whitelist:
- SUSE:SLFO:1.1:Staging:Y_-_standard.yaml
scripts:
auto_update: true
git: https://github.com/openSUSE/openSUSE-release-tools.git
whitelist:
- DO_NOT_TRIGGER
destination: scripts
stages:
- Checks:
jobs:
Check.Build.Succeeds:
resources:
- staging-bot
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s pending
./verify-repo-built-successful.py -A $STAGING_API -p $STAGING_PROJECT -r standard
Repo.Checker:
environment_variables:
OSC_CONFIG: /home/go/config/oscrc-staging-bot
resources:
- repo-checker
tasks:
- script: |-
./scripts/staging-installcheck.py -A $STAGING_API -p $SLFO_1_1_PROJECT -s $STAGING_PROJECT
- Update.000product:
resources:
- repo-checker
tasks:
- script: |-
export PYTHONPATH=$PWD/scripts
cd scripts/gocd
if ../pkglistgen.py --debug -A $STAGING_API update_and_solve --engine product_composer --staging $STAGING_PROJECT --force; then
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s success
else
./report-status.py -A $STAGING_API -p $STAGING_PROJECT -n packagelists -r standard -s failure
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
- Build.product:
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
timeout: 180
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
resources:
- staging-bot
tasks:
- script: |-
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
minutes=1
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=product&flag=build"
export PYTHONPATH=$PWD/scripts
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Let the scheduler warm up first
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
sleep 60
while osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -E 'statuscount code="(blocked|scheduled|building)"'; do
if [ ${minutes} -gt 180 ]; then
echo "Product is still building after timeout, exiting..." >&2
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
exit 1
slfo-stagings: add a timeout for Build.product, and do not run if repo is missing Ensure that the 'product' repo is configured in the project meta. Unfortunately, since we're checking in the configuration of the staging itself, rather than the parent project's, there are increased changes of some human/tooling error that might drop the repository from the configuration. This will make the job run an endless loop. Also, add a timeout for 180 minutes for the job. It is enough for the product build process, and if it isn't, it's better to cancel and have human eyes looking at it. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-17 16:24:01 +02:00
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
sleep 60
Add 180 minutes timeout to SLFO product building pipelines.
2024-11-07 14:29:12 +01:00
minutes=$(expr $minutes + 1)
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
done
gocd: slfo-stagings: properly escape comments Follow up to 4c1d7be5d10457fa4a1545cebef79275d09345cf Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 14:42:28 +01:00
## Always fail on broken/failed products
gocd: slfo-stagings: fail on broken/failed products Rather than using verify-repo-built-successful.py, check with the API directly whether the product is blocked, scheduled or building. Since it might happen for a product being broken/failed (even after a successful pkglistgen run), just fail in that case. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-11-12 12:32:32 +01:00
if osc -A $STAGING_API api -X GET "/build/$STAGING_PROJECT/_result?view=summary&repository=product&arch=local" | grep -qE 'statuscount code="(broken|failed)"'; then
echo "Some products failed to build, exiting..." >&2
exit 1
fi
gocd: slfo-stagings: wait for product to be built before enabling images During image testing, the artifacts built inside the 'product' repository are used. Let's ensure that the repository is fully built before attempting to enable images. Signed-off-by: Eugenio Paolantonio <eugenio.paolantonio@suse.com>
2024-06-11 10:57:50 +02:00
gocd: Add SLFO Stagings pipeline.
2024-05-20 09:51:53 +02:00
- Enable.images.repo:
resources:
- staging-bot
tasks:
- script: |-
osc -A $STAGING_API api -X POST "/source/$STAGING_PROJECT?cmd=remove_flag&repository=images&flag=build"
export PYTHONPATH=$PWD/scripts
while osc -A $STAGING_API api "/build/$STAGING_PROJECT/_result?view=summary&repository=images" | grep 'dirty=.true.'; do
sleep 60
done
./scripts/gocd/report-status.py -A $STAGING_API -p $STAGING_PROJECT -n images:enabled -r standard -s success
Reference in New Issue Copy Permalink