Add the simplest CI with make #47

Workflow file for this run

.github/workflows/test-make.yaml at f129eac

	name: Test (make)
	on:
	push:
	branches:
	- main
	- v3.13.x
	- v3.12.x
	- v3.11.x
	pull_request:
	concurrency:
	group: ${{ github.workflow }}-${{ github.event.pull_request.number \|\| github.ref }}
	cancel-in-progress: true
	jobs:
	load-test-result-cache:
	runs-on: ubuntu-latest
	outputs:
	hash: ${{ steps.hash.outputs.hash }}
	steps:
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	if: steps.check.outputs.passed != 'true'
	uses: erlef/setup-beam@v1
	with:
	otp-version: 26.2
	elixir-version: 1.15
	- name: ENSURE WORKFLOWS ARE UP TO DATE
	run: \|
	mkdir local-bin/
	curl -L https://carvel.dev/install.sh \| K14SIO_INSTALL_BIN_DIR=local-bin bash

	make actions-workflows YTT=$PWD/local-bin/ytt
	git diff --exit-code
	- name: COMPUTE REPO HASH
	id: hash
	run: \|
	echo "hash=${{ hashFiles('*/', '!.github/*/', '!.bazel', '!.bzl', '!BUILD.*') }}" \| tee -a $GITHUB_OUTPUT
	- name: MOUNT TEST RESULT CACHE
	uses: actions/[email protected]
	with:
	path: /home/runner/test-result-cache/
	key: ${{ runner.os }}-test-result-cache-${{ steps.hash.outputs.hash }}
	restore-keys: \|
	${{ runner.os }}-test-result-cache-
	- name: PREP CACHE DIR
	run: \|
	mkdir -p /home/runner/test-result-cache/${{ steps.hash.outputs.hash }}
	touch /home/runner/test-result-cache/marker
	- name: UPLOAD IT AS AN ARTIFACT
	uses: actions/upload-artifact@v4
	with:
	name: test-result-cache-subdir
	path: \|
	/home/runner/test-result-cache/marker
	/home/runner/test-result-cache/${{ steps.hash.outputs.hash }}
	retention-days: 7
	test-amqp10_client:
	name: Test amqp10_client
	needs:
	- load-test-result-cache
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/amqp10_client/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/amqp10_client \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/amqp10_client \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/amqp10_client \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT msg
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-msg ]]; then
	echo "ct-msg already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/amqp10_client \
	ct-msg \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-msg
	fi
	- name: CT system
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-system ]]; then
	echo "ct-system already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/amqp10_client \
	ct-system \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-system
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-amqp10_client-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-amqp10_client-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/amqp10_client/logs/*
	test-amqp10_common:
	name: Test amqp10_common
	needs:
	- load-test-result-cache
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/amqp10_common/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/amqp10_common \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/amqp10_common \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/amqp10_common \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT binary_generator
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-binary_generator ]]; then
	echo "ct-binary_generator already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/amqp10_common \
	ct-binary_generator \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-binary_generator
	fi
	- name: CT binary_parser
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-binary_parser ]]; then
	echo "ct-binary_parser already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/amqp10_common \
	ct-binary_parser \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-binary_parser
	fi
	- name: CT serial_number
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-serial_number ]]; then
	echo "ct-serial_number already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/amqp10_common \
	ct-serial_number \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-serial_number
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-amqp10_common-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-amqp10_common-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/amqp10_common/logs/*
	test-amqp_client:
	name: Test amqp_client
	needs:
	- load-test-result-cache
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/amqp_client/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/amqp_client \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/amqp_client \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/amqp_client \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT system
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-system ]]; then
	echo "ct-system already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/amqp_client \
	ct-system \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-system
	fi
	- name: CT unit
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit ]]; then
	echo "ct-unit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/amqp_client \
	ct-unit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-amqp_client-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-amqp_client-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/amqp_client/logs/*
	test-oauth2_client:
	name: Test oauth2_client
	needs:
	- load-test-result-cache
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/oauth2_client/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/oauth2_client \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/oauth2_client \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/oauth2_client \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT system
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-system ]]; then
	echo "ct-system already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/oauth2_client \
	ct-system \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-system
	fi
	- name: CT unit
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit ]]; then
	echo "ct-unit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/oauth2_client \
	ct-unit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-oauth2_client-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-oauth2_client-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/oauth2_client/logs/*
	test-rabbit_common:
	name: Test rabbit_common
	needs:
	- load-test-result-cache
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbit_common/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit_common \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit_common \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit_common \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT rabbit_env
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_env ]]; then
	echo "ct-rabbit_env already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit_common \
	ct-rabbit_env \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_env
	fi
	- name: CT supervisor2
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-supervisor2 ]]; then
	echo "ct-supervisor2 already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit_common \
	ct-supervisor2 \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-supervisor2
	fi
	- name: CT unit
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit ]]; then
	echo "ct-unit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit_common \
	ct-unit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit
	fi
	- name: CT unit_password_hashing
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_password_hashing ]]; then
	echo "ct-unit_password_hashing already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit_common \
	ct-unit_password_hashing \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_password_hashing
	fi
	- name: CT unit_priority_queue
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_priority_queue ]]; then
	echo "ct-unit_priority_queue already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit_common \
	ct-unit_priority_queue \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_priority_queue
	fi
	- name: CT worker_pool
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-worker_pool ]]; then
	echo "ct-worker_pool already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit_common \
	ct-worker_pool \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-worker_pool
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbit_common-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbit_common-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbit_common/logs/*
	test-rabbitmq_ct_client_helpers:
	name: Test rabbitmq_ct_client_helpers
	needs:
	- load-test-result-cache
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_ct_client_helpers/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_ct_client_helpers \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_ct_client_helpers \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_ct_client_helpers \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_ct_client_helpers-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_ct_client_helpers-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_ct_client_helpers/logs/*
	test-rabbitmq_ct_helpers:
	name: Test rabbitmq_ct_helpers
	needs:
	- load-test-result-cache
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_ct_helpers/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_ct_helpers \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_ct_helpers \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: true
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_ct_helpers \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT terraform
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-terraform ]]; then
	echo "ct-terraform already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_ct_helpers \
	ct-terraform \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-terraform
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_ct_helpers-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_ct_helpers-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_ct_helpers/logs/*
	test-rabbitmq_stream_common:
	name: Test rabbitmq_stream_common
	needs:
	- load-test-result-cache
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_stream_common/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stream_common \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stream_common \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stream_common \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT rabbit_stream_core
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_stream_core ]]; then
	echo "ct-rabbit_stream_core already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stream_common \
	ct-rabbit_stream_core \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_stream_core
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_stream_common-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_stream_common-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_stream_common/logs/*
	test-trust_store_http:
	name: Test trust_store_http
	needs:
	- load-test-result-cache
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/trust_store_http/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/trust_store_http \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/trust_store_http \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: true
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/trust_store_http \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-trust_store_http-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-trust_store_http-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/trust_store_http/logs/*
	test-rabbit:
	name: Test rabbit
	needs:
	- load-test-result-cache
	- test-amqp10_client
	- test-amqp10_common
	- test-amqp_client
	- test-oauth2_client
	- test-rabbit_common
	- test-rabbitmq_ct_client_helpers
	- test-rabbitmq_ct_helpers
	- test-rabbitmq_stream_common
	- test-trust_store_http
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbit/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT amqp_address
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-amqp_address ]]; then
	echo "ct-amqp_address already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-amqp_address \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-amqp_address
	fi
	- name: CT amqp_auth
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-amqp_auth ]]; then
	echo "ct-amqp_auth already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-amqp_auth \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-amqp_auth
	fi
	- name: CT amqp_client
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-amqp_client ]]; then
	echo "ct-amqp_client already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-amqp_client \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-amqp_client
	fi
	- name: CT amqp_credit_api_v2
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-amqp_credit_api_v2 ]]; then
	echo "ct-amqp_credit_api_v2 already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-amqp_credit_api_v2 \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-amqp_credit_api_v2
	fi
	- name: CT amqp_proxy_protocol
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-amqp_proxy_protocol ]]; then
	echo "ct-amqp_proxy_protocol already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-amqp_proxy_protocol \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-amqp_proxy_protocol
	fi
	- name: CT amqp_system
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-amqp_system ]]; then
	echo "ct-amqp_system already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-amqp_system \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-amqp_system
	fi
	- name: CT amqqueue_backward_compatibility
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-amqqueue_backward_compatibility ]]; then
	echo "ct-amqqueue_backward_compatibility already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-amqqueue_backward_compatibility \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-amqqueue_backward_compatibility
	fi
	- name: CT backing_queue
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-backing_queue ]]; then
	echo "ct-backing_queue already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-backing_queue \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-backing_queue
	fi
	- name: CT bindings
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-bindings ]]; then
	echo "ct-bindings already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-bindings \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-bindings
	fi
	- name: CT channel_interceptor
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-channel_interceptor ]]; then
	echo "ct-channel_interceptor already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-channel_interceptor \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-channel_interceptor
	fi
	- name: CT channel_operation_timeout
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-channel_operation_timeout ]]; then
	echo "ct-channel_operation_timeout already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-channel_operation_timeout \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-channel_operation_timeout
	fi
	- name: CT classic_queue_prop
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-classic_queue_prop ]]; then
	echo "ct-classic_queue_prop already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-classic_queue_prop \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-classic_queue_prop
	fi
	- name: CT cli_forget_cluster_node
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-cli_forget_cluster_node ]]; then
	echo "ct-cli_forget_cluster_node already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-cli_forget_cluster_node \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-cli_forget_cluster_node
	fi
	- name: CT cluster
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-cluster ]]; then
	echo "ct-cluster already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-cluster \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-cluster
	fi
	- name: CT cluster_minority
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-cluster_minority ]]; then
	echo "ct-cluster_minority already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-cluster_minority \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-cluster_minority
	fi
	- name: CT clustering_management
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-clustering_management ]]; then
	echo "ct-clustering_management already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-clustering_management \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-clustering_management
	fi
	- name: CT clustering_recovery
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-clustering_recovery ]]; then
	echo "ct-clustering_recovery already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-clustering_recovery \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-clustering_recovery
	fi
	- name: CT config_schema
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-config_schema ]]; then
	echo "ct-config_schema already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-config_schema \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-config_schema
	fi
	- name: CT confirms_rejects
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-confirms_rejects ]]; then
	echo "ct-confirms_rejects already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-confirms_rejects \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-confirms_rejects
	fi
	- name: CT consumer_timeout
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-consumer_timeout ]]; then
	echo "ct-consumer_timeout already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-consumer_timeout \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-consumer_timeout
	fi
	- name: CT crashing_queues
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-crashing_queues ]]; then
	echo "ct-crashing_queues already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-crashing_queues \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-crashing_queues
	fi
	- name: CT dead_lettering
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-dead_lettering ]]; then
	echo "ct-dead_lettering already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-dead_lettering \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-dead_lettering
	fi
	- name: CT definition_import
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-definition_import ]]; then
	echo "ct-definition_import already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-definition_import \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-definition_import
	fi
	- name: CT deprecated_features
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-deprecated_features ]]; then
	echo "ct-deprecated_features already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-deprecated_features \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-deprecated_features
	fi
	- name: CT direct_exchange_routing_v2
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-direct_exchange_routing_v2 ]]; then
	echo "ct-direct_exchange_routing_v2 already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-direct_exchange_routing_v2 \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-direct_exchange_routing_v2
	fi
	- name: CT disconnect_detected_during_alarm
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-disconnect_detected_during_alarm ]]; then
	echo "ct-disconnect_detected_during_alarm already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-disconnect_detected_during_alarm \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-disconnect_detected_during_alarm
	fi
	- name: CT disk_monitor
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-disk_monitor ]]; then
	echo "ct-disk_monitor already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-disk_monitor \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-disk_monitor
	fi
	- name: CT dynamic_ha
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-dynamic_ha ]]; then
	echo "ct-dynamic_ha already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-dynamic_ha \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-dynamic_ha
	fi
	- name: CT dynamic_qq
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-dynamic_qq ]]; then
	echo "ct-dynamic_qq already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-dynamic_qq \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-dynamic_qq
	fi
	- name: CT eager_sync
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-eager_sync ]]; then
	echo "ct-eager_sync already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-eager_sync \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-eager_sync
	fi
	- name: CT exchanges
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-exchanges ]]; then
	echo "ct-exchanges already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-exchanges \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-exchanges
	fi
	- name: CT feature_flags
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-feature_flags ]]; then
	echo "ct-feature_flags already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-feature_flags \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-feature_flags
	fi
	- name: CT feature_flags_v2
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-feature_flags_v2 ]]; then
	echo "ct-feature_flags_v2 already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-feature_flags_v2 \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-feature_flags_v2
	fi
	- name: CT feature_flags_with_unpriveleged_user
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-feature_flags_with_unpriveleged_user ]]; then
	echo "ct-feature_flags_with_unpriveleged_user already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-feature_flags_with_unpriveleged_user \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-feature_flags_with_unpriveleged_user
	fi
	- name: CT list_consumers_sanity_check
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-list_consumers_sanity_check ]]; then
	echo "ct-list_consumers_sanity_check already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-list_consumers_sanity_check \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-list_consumers_sanity_check
	fi
	- name: CT list_queues_online_and_offline
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-list_queues_online_and_offline ]]; then
	echo "ct-list_queues_online_and_offline already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-list_queues_online_and_offline \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-list_queues_online_and_offline
	fi
	- name: CT logging
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-logging ]]; then
	echo "ct-logging already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-logging \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-logging
	fi
	- name: CT lqueue
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-lqueue ]]; then
	echo "ct-lqueue already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-lqueue \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-lqueue
	fi
	- name: CT maintenance_mode
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-maintenance_mode ]]; then
	echo "ct-maintenance_mode already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-maintenance_mode \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-maintenance_mode
	fi
	- name: CT many_node_ha
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-many_node_ha ]]; then
	echo "ct-many_node_ha already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-many_node_ha \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-many_node_ha
	fi
	- name: CT mc_unit
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-mc_unit ]]; then
	echo "ct-mc_unit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-mc_unit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-mc_unit
	fi
	- name: CT message_size_limit
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-message_size_limit ]]; then
	echo "ct-message_size_limit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-message_size_limit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-message_size_limit
	fi
	- name: CT metadata_store_clustering
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-metadata_store_clustering ]]; then
	echo "ct-metadata_store_clustering already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-metadata_store_clustering \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-metadata_store_clustering
	fi
	- name: CT metadata_store_migration
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-metadata_store_migration ]]; then
	echo "ct-metadata_store_migration already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-metadata_store_migration \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-metadata_store_migration
	fi
	- name: CT metadata_store_phase1
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-metadata_store_phase1 ]]; then
	echo "ct-metadata_store_phase1 already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-metadata_store_phase1 \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-metadata_store_phase1
	fi
	- name: CT metrics
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-metrics ]]; then
	echo "ct-metrics already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-metrics \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-metrics
	fi
	- name: CT mirrored_supervisor
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-mirrored_supervisor ]]; then
	echo "ct-mirrored_supervisor already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-mirrored_supervisor \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-mirrored_supervisor
	fi
	- name: CT msg_store
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-msg_store ]]; then
	echo "ct-msg_store already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-msg_store \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-msg_store
	fi
	- name: CT peer_discovery_classic_config
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-peer_discovery_classic_config ]]; then
	echo "ct-peer_discovery_classic_config already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-peer_discovery_classic_config \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-peer_discovery_classic_config
	fi
	- name: CT peer_discovery_dns
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-peer_discovery_dns ]]; then
	echo "ct-peer_discovery_dns already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-peer_discovery_dns \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-peer_discovery_dns
	fi
	- name: CT peer_discovery_tmp_hidden_node
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-peer_discovery_tmp_hidden_node ]]; then
	echo "ct-peer_discovery_tmp_hidden_node already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-peer_discovery_tmp_hidden_node \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-peer_discovery_tmp_hidden_node
	fi
	- name: CT per_node_limit
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-per_node_limit ]]; then
	echo "ct-per_node_limit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-per_node_limit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-per_node_limit
	fi
	- name: CT per_user_connection_channel_limit
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-per_user_connection_channel_limit ]]; then
	echo "ct-per_user_connection_channel_limit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-per_user_connection_channel_limit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-per_user_connection_channel_limit
	fi
	- name: CT per_user_connection_channel_limit_partitions
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-per_user_connection_channel_limit_partitions ]]; then
	echo "ct-per_user_connection_channel_limit_partitions already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-per_user_connection_channel_limit_partitions \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-per_user_connection_channel_limit_partitions
	fi
	- name: CT per_user_connection_channel_tracking
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-per_user_connection_channel_tracking ]]; then
	echo "ct-per_user_connection_channel_tracking already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-per_user_connection_channel_tracking \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-per_user_connection_channel_tracking
	fi
	- name: CT per_user_connection_tracking
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-per_user_connection_tracking ]]; then
	echo "ct-per_user_connection_tracking already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-per_user_connection_tracking \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-per_user_connection_tracking
	fi
	- name: CT per_vhost_connection_limit
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-per_vhost_connection_limit ]]; then
	echo "ct-per_vhost_connection_limit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-per_vhost_connection_limit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-per_vhost_connection_limit
	fi
	- name: CT per_vhost_connection_limit_partitions
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-per_vhost_connection_limit_partitions ]]; then
	echo "ct-per_vhost_connection_limit_partitions already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-per_vhost_connection_limit_partitions \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-per_vhost_connection_limit_partitions
	fi
	- name: CT per_vhost_msg_store
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-per_vhost_msg_store ]]; then
	echo "ct-per_vhost_msg_store already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-per_vhost_msg_store \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-per_vhost_msg_store
	fi
	- name: CT per_vhost_queue_limit
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-per_vhost_queue_limit ]]; then
	echo "ct-per_vhost_queue_limit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-per_vhost_queue_limit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-per_vhost_queue_limit
	fi
	- name: CT policy
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-policy ]]; then
	echo "ct-policy already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-policy \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-policy
	fi
	- name: CT priority_queue
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-priority_queue ]]; then
	echo "ct-priority_queue already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-priority_queue \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-priority_queue
	fi
	- name: CT priority_queue_recovery
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-priority_queue_recovery ]]; then
	echo "ct-priority_queue_recovery already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-priority_queue_recovery \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-priority_queue_recovery
	fi
	- name: CT product_info
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-product_info ]]; then
	echo "ct-product_info already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-product_info \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-product_info
	fi
	- name: CT proxy_protocol
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-proxy_protocol ]]; then
	echo "ct-proxy_protocol already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-proxy_protocol \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-proxy_protocol
	fi
	- name: CT publisher_confirms_parallel
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-publisher_confirms_parallel ]]; then
	echo "ct-publisher_confirms_parallel already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-publisher_confirms_parallel \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-publisher_confirms_parallel
	fi
	- name: CT queue_length_limits
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-queue_length_limits ]]; then
	echo "ct-queue_length_limits already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-queue_length_limits \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-queue_length_limits
	fi
	- name: CT queue_master_location
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-queue_master_location ]]; then
	echo "ct-queue_master_location already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-queue_master_location \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-queue_master_location
	fi
	- name: CT queue_parallel
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-queue_parallel ]]; then
	echo "ct-queue_parallel already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-queue_parallel \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-queue_parallel
	fi
	- name: CT queue_type
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-queue_type ]]; then
	echo "ct-queue_type already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-queue_type \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-queue_type
	fi
	- name: CT quorum_queue
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-quorum_queue ]]; then
	echo "ct-quorum_queue already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-quorum_queue \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-quorum_queue
	fi
	- name: CT quorum_queue_member_reconciliation
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-quorum_queue_member_reconciliation ]]; then
	echo "ct-quorum_queue_member_reconciliation already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-quorum_queue_member_reconciliation \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-quorum_queue_member_reconciliation
	fi
	- name: CT rabbit_access_control
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_access_control ]]; then
	echo "ct-rabbit_access_control already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_access_control \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_access_control
	fi
	- name: CT rabbit_confirms
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_confirms ]]; then
	echo "ct-rabbit_confirms already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_confirms \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_confirms
	fi
	- name: CT rabbit_core_metrics_gc
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_core_metrics_gc ]]; then
	echo "ct-rabbit_core_metrics_gc already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_core_metrics_gc \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_core_metrics_gc
	fi
	- name: CT rabbit_cuttlefish
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_cuttlefish ]]; then
	echo "ct-rabbit_cuttlefish already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_cuttlefish \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_cuttlefish
	fi
	- name: CT rabbit_db_binding
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_db_binding ]]; then
	echo "ct-rabbit_db_binding already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_db_binding \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_db_binding
	fi
	- name: CT rabbit_db_exchange
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_db_exchange ]]; then
	echo "ct-rabbit_db_exchange already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_db_exchange \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_db_exchange
	fi
	- name: CT rabbit_db_maintenance
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_db_maintenance ]]; then
	echo "ct-rabbit_db_maintenance already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_db_maintenance \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_db_maintenance
	fi
	- name: CT rabbit_db_msup
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_db_msup ]]; then
	echo "ct-rabbit_db_msup already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_db_msup \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_db_msup
	fi
	- name: CT rabbit_db_policy
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_db_policy ]]; then
	echo "ct-rabbit_db_policy already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_db_policy \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_db_policy
	fi
	- name: CT rabbit_db_queue
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_db_queue ]]; then
	echo "ct-rabbit_db_queue already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_db_queue \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_db_queue
	fi
	- name: CT rabbit_db_topic_exchange
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_db_topic_exchange ]]; then
	echo "ct-rabbit_db_topic_exchange already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_db_topic_exchange \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_db_topic_exchange
	fi
	- name: CT rabbit_direct_reply_to_prop
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_direct_reply_to_prop ]]; then
	echo "ct-rabbit_direct_reply_to_prop already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_direct_reply_to_prop \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_direct_reply_to_prop
	fi
	- name: CT rabbit_fifo
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_fifo ]]; then
	echo "ct-rabbit_fifo already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_fifo \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_fifo
	fi
	- name: CT rabbit_fifo_dlx
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_fifo_dlx ]]; then
	echo "ct-rabbit_fifo_dlx already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_fifo_dlx \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_fifo_dlx
	fi
	- name: CT rabbit_fifo_dlx_integration
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_fifo_dlx_integration ]]; then
	echo "ct-rabbit_fifo_dlx_integration already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_fifo_dlx_integration \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_fifo_dlx_integration
	fi
	- name: CT rabbit_fifo_int
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_fifo_int ]]; then
	echo "ct-rabbit_fifo_int already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_fifo_int \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_fifo_int
	fi
	- name: CT rabbit_fifo_prop
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_fifo_prop ]]; then
	echo "ct-rabbit_fifo_prop already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_fifo_prop \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_fifo_prop
	fi
	- name: CT rabbit_fifo_v0
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_fifo_v0 ]]; then
	echo "ct-rabbit_fifo_v0 already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_fifo_v0 \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_fifo_v0
	fi
	- name: CT rabbit_message_interceptor
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_message_interceptor ]]; then
	echo "ct-rabbit_message_interceptor already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_message_interceptor \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_message_interceptor
	fi
	- name: CT rabbit_msg_record
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_msg_record ]]; then
	echo "ct-rabbit_msg_record already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_msg_record \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_msg_record
	fi
	- name: CT rabbit_stream_coordinator
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_stream_coordinator ]]; then
	echo "ct-rabbit_stream_coordinator already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_stream_coordinator \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_stream_coordinator
	fi
	- name: CT rabbit_stream_queue
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_stream_queue ]]; then
	echo "ct-rabbit_stream_queue already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_stream_queue \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_stream_queue
	fi
	- name: CT rabbit_stream_sac_coordinator
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_stream_sac_coordinator ]]; then
	echo "ct-rabbit_stream_sac_coordinator already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbit_stream_sac_coordinator \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_stream_sac_coordinator
	fi
	- name: CT rabbitmq_4_0_deprecations
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbitmq_4_0_deprecations ]]; then
	echo "ct-rabbitmq_4_0_deprecations already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbitmq_4_0_deprecations \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbitmq_4_0_deprecations
	fi
	- name: CT rabbitmq_queues_cli_integration
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbitmq_queues_cli_integration ]]; then
	echo "ct-rabbitmq_queues_cli_integration already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbitmq_queues_cli_integration \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbitmq_queues_cli_integration
	fi
	- name: CT rabbitmqctl_integration
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbitmqctl_integration ]]; then
	echo "ct-rabbitmqctl_integration already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbitmqctl_integration \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbitmqctl_integration
	fi
	- name: CT rabbitmqctl_shutdown
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbitmqctl_shutdown ]]; then
	echo "ct-rabbitmqctl_shutdown already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-rabbitmqctl_shutdown \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbitmqctl_shutdown
	fi
	- name: CT routing
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-routing ]]; then
	echo "ct-routing already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-routing \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-routing
	fi
	- name: CT runtime_parameters
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-runtime_parameters ]]; then
	echo "ct-runtime_parameters already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-runtime_parameters \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-runtime_parameters
	fi
	- name: CT signal_handling
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-signal_handling ]]; then
	echo "ct-signal_handling already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-signal_handling \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-signal_handling
	fi
	- name: CT simple_ha
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-simple_ha ]]; then
	echo "ct-simple_ha already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-simple_ha \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-simple_ha
	fi
	- name: CT single_active_consumer
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-single_active_consumer ]]; then
	echo "ct-single_active_consumer already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-single_active_consumer \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-single_active_consumer
	fi
	- name: CT sync_detection
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-sync_detection ]]; then
	echo "ct-sync_detection already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-sync_detection \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-sync_detection
	fi
	- name: CT term_to_binary_compat_prop
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-term_to_binary_compat_prop ]]; then
	echo "ct-term_to_binary_compat_prop already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-term_to_binary_compat_prop \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-term_to_binary_compat_prop
	fi
	- name: CT topic_permission
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-topic_permission ]]; then
	echo "ct-topic_permission already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-topic_permission \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-topic_permission
	fi
	- name: CT transactions
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-transactions ]]; then
	echo "ct-transactions already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-transactions \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-transactions
	fi
	- name: CT unicode
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unicode ]]; then
	echo "ct-unicode already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unicode \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unicode
	fi
	- name: CT unit_access_control
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_access_control ]]; then
	echo "ct-unit_access_control already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_access_control \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_access_control
	fi
	- name: CT unit_access_control_authn_authz_context_propagation
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_access_control_authn_authz_context_propagation ]]; then
	echo "ct-unit_access_control_authn_authz_context_propagation already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_access_control_authn_authz_context_propagation \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_access_control_authn_authz_context_propagation
	fi
	- name: CT unit_access_control_credential_validation
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_access_control_credential_validation ]]; then
	echo "ct-unit_access_control_credential_validation already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_access_control_credential_validation \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_access_control_credential_validation
	fi
	- name: CT unit_amqp091_content_framing
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_amqp091_content_framing ]]; then
	echo "ct-unit_amqp091_content_framing already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_amqp091_content_framing \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_amqp091_content_framing
	fi
	- name: CT unit_amqp091_server_properties
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_amqp091_server_properties ]]; then
	echo "ct-unit_amqp091_server_properties already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_amqp091_server_properties \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_amqp091_server_properties
	fi
	- name: CT unit_app_management
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_app_management ]]; then
	echo "ct-unit_app_management already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_app_management \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_app_management
	fi
	- name: CT unit_classic_mirrored_queue_sync_throttling
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_classic_mirrored_queue_sync_throttling ]]; then
	echo "ct-unit_classic_mirrored_queue_sync_throttling already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_classic_mirrored_queue_sync_throttling \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_classic_mirrored_queue_sync_throttling
	fi
	- name: CT unit_classic_mirrored_queue_throughput
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_classic_mirrored_queue_throughput ]]; then
	echo "ct-unit_classic_mirrored_queue_throughput already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_classic_mirrored_queue_throughput \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_classic_mirrored_queue_throughput
	fi
	- name: CT unit_cluster_formation_locking_mocks
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_cluster_formation_locking_mocks ]]; then
	echo "ct-unit_cluster_formation_locking_mocks already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_cluster_formation_locking_mocks \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_cluster_formation_locking_mocks
	fi
	- name: CT unit_cluster_formation_sort_nodes
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_cluster_formation_sort_nodes ]]; then
	echo "ct-unit_cluster_formation_sort_nodes already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_cluster_formation_sort_nodes \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_cluster_formation_sort_nodes
	fi
	- name: CT unit_collections
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_collections ]]; then
	echo "ct-unit_collections already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_collections \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_collections
	fi
	- name: CT unit_config_value_encryption
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_config_value_encryption ]]; then
	echo "ct-unit_config_value_encryption already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_config_value_encryption \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_config_value_encryption
	fi
	- name: CT unit_connection_tracking
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_connection_tracking ]]; then
	echo "ct-unit_connection_tracking already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_connection_tracking \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_connection_tracking
	fi
	- name: CT unit_credit_flow
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_credit_flow ]]; then
	echo "ct-unit_credit_flow already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_credit_flow \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_credit_flow
	fi
	- name: CT unit_disk_monitor
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_disk_monitor ]]; then
	echo "ct-unit_disk_monitor already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_disk_monitor \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_disk_monitor
	fi
	- name: CT unit_file_handle_cache
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_file_handle_cache ]]; then
	echo "ct-unit_file_handle_cache already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_file_handle_cache \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_file_handle_cache
	fi
	- name: CT unit_gen_server2
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_gen_server2 ]]; then
	echo "ct-unit_gen_server2 already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_gen_server2 \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_gen_server2
	fi
	- name: CT unit_gm
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_gm ]]; then
	echo "ct-unit_gm already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_gm \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_gm
	fi
	- name: CT unit_log_management
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_log_management ]]; then
	echo "ct-unit_log_management already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_log_management \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_log_management
	fi
	- name: CT unit_operator_policy
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_operator_policy ]]; then
	echo "ct-unit_operator_policy already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_operator_policy \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_operator_policy
	fi
	- name: CT unit_pg_local
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_pg_local ]]; then
	echo "ct-unit_pg_local already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_pg_local \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_pg_local
	fi
	- name: CT unit_plugin_directories
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_plugin_directories ]]; then
	echo "ct-unit_plugin_directories already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_plugin_directories \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_plugin_directories
	fi
	- name: CT unit_plugin_versioning
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_plugin_versioning ]]; then
	echo "ct-unit_plugin_versioning already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_plugin_versioning \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_plugin_versioning
	fi
	- name: CT unit_policy_validators
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_policy_validators ]]; then
	echo "ct-unit_policy_validators already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_policy_validators \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_policy_validators
	fi
	- name: CT unit_priority_queue
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_priority_queue ]]; then
	echo "ct-unit_priority_queue already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_priority_queue \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_priority_queue
	fi
	- name: CT unit_queue_consumers
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_queue_consumers ]]; then
	echo "ct-unit_queue_consumers already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_queue_consumers \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_queue_consumers
	fi
	- name: CT unit_quorum_queue
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_quorum_queue ]]; then
	echo "ct-unit_quorum_queue already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_quorum_queue \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_quorum_queue
	fi
	- name: CT unit_stats_and_metrics
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_stats_and_metrics ]]; then
	echo "ct-unit_stats_and_metrics already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_stats_and_metrics \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_stats_and_metrics
	fi
	- name: CT unit_supervisor2
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_supervisor2 ]]; then
	echo "ct-unit_supervisor2 already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_supervisor2 \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_supervisor2
	fi
	- name: CT unit_vm_memory_monitor
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_vm_memory_monitor ]]; then
	echo "ct-unit_vm_memory_monitor already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-unit_vm_memory_monitor \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_vm_memory_monitor
	fi
	- name: CT upgrade_preparation
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-upgrade_preparation ]]; then
	echo "ct-upgrade_preparation already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-upgrade_preparation \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-upgrade_preparation
	fi
	- name: CT vhost
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-vhost ]]; then
	echo "ct-vhost already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbit \
	ct-vhost \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-vhost
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbit-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbit-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbit/logs/*
	test-rabbitmq_cli:
	name: Test rabbitmq_cli
	needs:
	- load-test-result-cache
	- test-rabbit
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 20
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_cli/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECK IF ALREADY PASSED
	id: check
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }} ]]; then
	echo "passed=true" \| tee -a $GITHUB_OUTPUT
	else
	echo "passed=false" \| tee -a $GITHUB_OUTPUT
	fi
	- name: CHECKOUT REPOSITORY
	if: steps.check.outputs.passed != 'true'
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	if: steps.check.outputs.passed != 'true'
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	if: steps.check.outputs.passed != 'true'
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	- name: TEST
	id: test
	if: steps.check.outputs.passed != 'true'
	run: \|
	make -C deps/rabbitmq_cli \
	checks \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	- name: RECORD SUCCESS rabbitmq_cli
	if: steps.check.outputs.passed != 'true'
	run: \|
	set -x
	mkdir -p $(dirname ${{ env.SUCCESS_PATH }})
	echo "passed" > ${{ env.SUCCESS_PATH }}
	- name: UPDATE CACHE
	if: steps.check.outputs.passed != 'true'
	uses: actions/[email protected]
	with:
	name: rabbitmq_cli-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always() && steps.check.outputs.passed != 'true'
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_cli-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	deps/rabbitmq_cli/logs/*
	test-rabbitmq_amqp_client:
	name: Test rabbitmq_amqp_client
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_amqp_client/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_amqp_client \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_amqp_client \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_amqp_client \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT management
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-management ]]; then
	echo "ct-management already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_amqp_client \
	ct-management \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-management
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_amqp_client-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_amqp_client-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_amqp_client/logs/*
	test-rabbitmq_amqp1_0:
	name: Test rabbitmq_amqp1_0
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_amqp1_0/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_amqp1_0 \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_amqp1_0 \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_amqp1_0 \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_amqp1_0-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_amqp1_0-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_amqp1_0/logs/*
	test-rabbitmq_auth_backend_cache:
	name: Test rabbitmq_auth_backend_cache
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_auth_backend_cache/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_cache \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_cache \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_cache \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT config_schema
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-config_schema ]]; then
	echo "ct-config_schema already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_cache \
	ct-config_schema \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-config_schema
	fi
	- name: CT rabbit_auth_backend_cache
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_auth_backend_cache ]]; then
	echo "ct-rabbit_auth_backend_cache already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_cache \
	ct-rabbit_auth_backend_cache \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_auth_backend_cache
	fi
	- name: CT rabbit_auth_cache
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_auth_cache ]]; then
	echo "ct-rabbit_auth_cache already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_cache \
	ct-rabbit_auth_cache \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_auth_cache
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_auth_backend_cache-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_auth_backend_cache-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_auth_backend_cache/logs/*
	test-rabbitmq_auth_backend_http:
	name: Test rabbitmq_auth_backend_http
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_auth_backend_http/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_http \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_http \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_http \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT auth
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-auth ]]; then
	echo "ct-auth already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_http \
	ct-auth \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-auth
	fi
	- name: CT config_schema
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-config_schema ]]; then
	echo "ct-config_schema already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_http \
	ct-config_schema \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-config_schema
	fi
	- name: CT unit
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit ]]; then
	echo "ct-unit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_http \
	ct-unit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_auth_backend_http-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_auth_backend_http-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_auth_backend_http/logs/*
	test-rabbitmq_auth_backend_ldap:
	name: Test rabbitmq_auth_backend_ldap
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_auth_backend_ldap/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_ldap \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_ldap \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_ldap \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT config_schema
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-config_schema ]]; then
	echo "ct-config_schema already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_ldap \
	ct-config_schema \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-config_schema
	fi
	- name: CT system
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-system ]]; then
	echo "ct-system already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_ldap \
	ct-system \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-system
	fi
	- name: CT unit
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit ]]; then
	echo "ct-unit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_ldap \
	ct-unit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_auth_backend_ldap-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_auth_backend_ldap-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_auth_backend_ldap/logs/*
	test-rabbitmq_auth_backend_oauth2:
	name: Test rabbitmq_auth_backend_oauth2
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_auth_backend_oauth2/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_oauth2 \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_oauth2 \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_oauth2 \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT add_signing_key_command
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-add_signing_key_command ]]; then
	echo "ct-add_signing_key_command already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_oauth2 \
	ct-add_signing_key_command \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-add_signing_key_command
	fi
	- name: CT add_uaa_key_command
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-add_uaa_key_command ]]; then
	echo "ct-add_uaa_key_command already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_oauth2 \
	ct-add_uaa_key_command \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-add_uaa_key_command
	fi
	- name: CT config_schema
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-config_schema ]]; then
	echo "ct-config_schema already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_oauth2 \
	ct-config_schema \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-config_schema
	fi
	- name: CT jwks
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-jwks ]]; then
	echo "ct-jwks already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_oauth2 \
	ct-jwks \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-jwks
	fi
	- name: CT rabbit_oauth2_config
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_oauth2_config ]]; then
	echo "ct-rabbit_oauth2_config already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_oauth2 \
	ct-rabbit_oauth2_config \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_oauth2_config
	fi
	- name: CT scope
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-scope ]]; then
	echo "ct-scope already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_oauth2 \
	ct-scope \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-scope
	fi
	- name: CT system
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-system ]]; then
	echo "ct-system already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_oauth2 \
	ct-system \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-system
	fi
	- name: CT unit
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit ]]; then
	echo "ct-unit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_oauth2 \
	ct-unit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit
	fi
	- name: CT wildcard_match
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-wildcard_match ]]; then
	echo "ct-wildcard_match already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_backend_oauth2 \
	ct-wildcard_match \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-wildcard_match
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_auth_backend_oauth2-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_auth_backend_oauth2-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_auth_backend_oauth2/logs/*
	test-rabbitmq_auth_mechanism_ssl:
	name: Test rabbitmq_auth_mechanism_ssl
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_auth_mechanism_ssl/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_mechanism_ssl \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_mechanism_ssl \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_auth_mechanism_ssl \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_auth_mechanism_ssl-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_auth_mechanism_ssl-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_auth_mechanism_ssl/logs/*
	test-rabbitmq_aws:
	name: Test rabbitmq_aws
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_aws/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_aws \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_aws \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_aws \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_aws-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_aws-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_aws/logs/*
	test-rabbitmq_consistent_hash_exchange:
	name: Test rabbitmq_consistent_hash_exchange
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_consistent_hash_exchange/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_consistent_hash_exchange \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_consistent_hash_exchange \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_consistent_hash_exchange \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT rabbit_exchange_type_consistent_hash
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_exchange_type_consistent_hash ]]; then
	echo "ct-rabbit_exchange_type_consistent_hash already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_consistent_hash_exchange \
	ct-rabbit_exchange_type_consistent_hash \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_exchange_type_consistent_hash
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_consistent_hash_exchange-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_consistent_hash_exchange-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_consistent_hash_exchange/logs/*
	test-rabbitmq_event_exchange:
	name: Test rabbitmq_event_exchange
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_event_exchange/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_event_exchange \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_event_exchange \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_event_exchange \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT config_schema
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-config_schema ]]; then
	echo "ct-config_schema already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_event_exchange \
	ct-config_schema \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-config_schema
	fi
	- name: CT system
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-system ]]; then
	echo "ct-system already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_event_exchange \
	ct-system \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-system
	fi
	- name: CT unit
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit ]]; then
	echo "ct-unit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_event_exchange \
	ct-unit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_event_exchange-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_event_exchange-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_event_exchange/logs/*
	test-rabbitmq_federation:
	name: Test rabbitmq_federation
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_federation/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_federation \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_federation \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_federation \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT exchange
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-exchange ]]; then
	echo "ct-exchange already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_federation \
	ct-exchange \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-exchange
	fi
	- name: CT federation_status_command
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-federation_status_command ]]; then
	echo "ct-federation_status_command already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_federation \
	ct-federation_status_command \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-federation_status_command
	fi
	- name: CT queue
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-queue ]]; then
	echo "ct-queue already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_federation \
	ct-queue \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-queue
	fi
	- name: CT rabbit_federation_status
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_federation_status ]]; then
	echo "ct-rabbit_federation_status already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_federation \
	ct-rabbit_federation_status \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_federation_status
	fi
	- name: CT restart_federation_link_command
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-restart_federation_link_command ]]; then
	echo "ct-restart_federation_link_command already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_federation \
	ct-restart_federation_link_command \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-restart_federation_link_command
	fi
	- name: CT unit
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit ]]; then
	echo "ct-unit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_federation \
	ct-unit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit
	fi
	- name: CT unit_inbroker
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit_inbroker ]]; then
	echo "ct-unit_inbroker already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_federation \
	ct-unit_inbroker \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit_inbroker
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_federation-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_federation-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_federation/logs/*
	test-rabbitmq_federation_management:
	name: Test rabbitmq_federation_management
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_federation_management/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_federation_management \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_federation_management \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_federation_management \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT federation_mgmt
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-federation_mgmt ]]; then
	echo "ct-federation_mgmt already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_federation_management \
	ct-federation_mgmt \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-federation_mgmt
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_federation_management-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_federation_management-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_federation_management/logs/*
	test-rabbitmq_jms_topic_exchange:
	name: Test rabbitmq_jms_topic_exchange
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_jms_topic_exchange/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_jms_topic_exchange \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_jms_topic_exchange \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_jms_topic_exchange \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT rjms_topic_selector
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rjms_topic_selector ]]; then
	echo "ct-rjms_topic_selector already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_jms_topic_exchange \
	ct-rjms_topic_selector \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rjms_topic_selector
	fi
	- name: CT rjms_topic_selector_unit
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rjms_topic_selector_unit ]]; then
	echo "ct-rjms_topic_selector_unit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_jms_topic_exchange \
	ct-rjms_topic_selector_unit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rjms_topic_selector_unit
	fi
	- name: CT sjx_evaluation
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-sjx_evaluation ]]; then
	echo "ct-sjx_evaluation already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_jms_topic_exchange \
	ct-sjx_evaluation \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-sjx_evaluation
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_jms_topic_exchange-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_jms_topic_exchange-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_jms_topic_exchange/logs/*
	test-rabbitmq_management:
	name: Test rabbitmq_management
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_management/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT cache
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-cache ]]; then
	echo "ct-cache already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management \
	ct-cache \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-cache
	fi
	- name: CT clustering
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-clustering ]]; then
	echo "ct-clustering already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management \
	ct-clustering \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-clustering
	fi
	- name: CT clustering_prop
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-clustering_prop ]]; then
	echo "ct-clustering_prop already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management \
	ct-clustering_prop \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-clustering_prop
	fi
	- name: CT config_schema
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-config_schema ]]; then
	echo "ct-config_schema already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management \
	ct-config_schema \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-config_schema
	fi
	- name: CT listener_config
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-listener_config ]]; then
	echo "ct-listener_config already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management \
	ct-listener_config \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-listener_config
	fi
	- name: CT rabbit_mgmt_http
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_mgmt_http ]]; then
	echo "ct-rabbit_mgmt_http already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management \
	ct-rabbit_mgmt_http \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_mgmt_http
	fi
	- name: CT rabbit_mgmt_http_health_checks
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_mgmt_http_health_checks ]]; then
	echo "ct-rabbit_mgmt_http_health_checks already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management \
	ct-rabbit_mgmt_http_health_checks \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_mgmt_http_health_checks
	fi
	- name: CT rabbit_mgmt_only_http
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_mgmt_only_http ]]; then
	echo "ct-rabbit_mgmt_only_http already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management \
	ct-rabbit_mgmt_only_http \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_mgmt_only_http
	fi
	- name: CT rabbit_mgmt_rabbitmqadmin
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_mgmt_rabbitmqadmin ]]; then
	echo "ct-rabbit_mgmt_rabbitmqadmin already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management \
	ct-rabbit_mgmt_rabbitmqadmin \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_mgmt_rabbitmqadmin
	fi
	- name: CT rabbit_mgmt_stats
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_mgmt_stats ]]; then
	echo "ct-rabbit_mgmt_stats already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management \
	ct-rabbit_mgmt_stats \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_mgmt_stats
	fi
	- name: CT rabbit_mgmt_test_db
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_mgmt_test_db ]]; then
	echo "ct-rabbit_mgmt_test_db already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management \
	ct-rabbit_mgmt_test_db \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_mgmt_test_db
	fi
	- name: CT rabbit_mgmt_test_unit
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_mgmt_test_unit ]]; then
	echo "ct-rabbit_mgmt_test_unit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management \
	ct-rabbit_mgmt_test_unit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_mgmt_test_unit
	fi
	- name: CT rabbit_mgmt_wm_auth
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_mgmt_wm_auth ]]; then
	echo "ct-rabbit_mgmt_wm_auth already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management \
	ct-rabbit_mgmt_wm_auth \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_mgmt_wm_auth
	fi
	- name: CT stats
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-stats ]]; then
	echo "ct-stats already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management \
	ct-stats \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-stats
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_management-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_management-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_management/logs/*
	test-rabbitmq_management_agent:
	name: Test rabbitmq_management_agent
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_management_agent/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management_agent \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management_agent \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management_agent \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT exometer_slide
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-exometer_slide ]]; then
	echo "ct-exometer_slide already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management_agent \
	ct-exometer_slide \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-exometer_slide
	fi
	- name: CT metrics
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-metrics ]]; then
	echo "ct-metrics already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management_agent \
	ct-metrics \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-metrics
	fi
	- name: CT rabbit_mgmt_gc
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_mgmt_gc ]]; then
	echo "ct-rabbit_mgmt_gc already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management_agent \
	ct-rabbit_mgmt_gc \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_mgmt_gc
	fi
	- name: CT rabbit_mgmt_slide
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_mgmt_slide ]]; then
	echo "ct-rabbit_mgmt_slide already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_management_agent \
	ct-rabbit_mgmt_slide \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_mgmt_slide
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_management_agent-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_management_agent-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_management_agent/logs/*
	test-rabbitmq_mqtt:
	name: Test rabbitmq_mqtt
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_mqtt/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT auth
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-auth ]]; then
	echo "ct-auth already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	ct-auth \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-auth
	fi
	- name: CT cluster
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-cluster ]]; then
	echo "ct-cluster already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	ct-cluster \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-cluster
	fi
	- name: CT command
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-command ]]; then
	echo "ct-command already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	ct-command \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-command
	fi
	- name: CT config
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-config ]]; then
	echo "ct-config already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	ct-config \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-config
	fi
	- name: CT config_schema
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-config_schema ]]; then
	echo "ct-config_schema already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	ct-config_schema \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-config_schema
	fi
	- name: CT ff
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-ff ]]; then
	echo "ct-ff already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	ct-ff \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-ff
	fi
	- name: CT java
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-java ]]; then
	echo "ct-java already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	ct-java \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-java
	fi
	- name: CT mc_mqtt
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-mc_mqtt ]]; then
	echo "ct-mc_mqtt already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	ct-mc_mqtt \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-mc_mqtt
	fi
	- name: CT mqtt_machine
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-mqtt_machine ]]; then
	echo "ct-mqtt_machine already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	ct-mqtt_machine \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-mqtt_machine
	fi
	- name: CT packet_prop
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-packet_prop ]]; then
	echo "ct-packet_prop already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	ct-packet_prop \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-packet_prop
	fi
	- name: CT processor
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-processor ]]; then
	echo "ct-processor already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	ct-processor \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-processor
	fi
	- name: CT protocol_interop
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-protocol_interop ]]; then
	echo "ct-protocol_interop already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	ct-protocol_interop \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-protocol_interop
	fi
	- name: CT proxy_protocol
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-proxy_protocol ]]; then
	echo "ct-proxy_protocol already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	ct-proxy_protocol \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-proxy_protocol
	fi
	- name: CT rabbit_mqtt_confirms
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_mqtt_confirms ]]; then
	echo "ct-rabbit_mqtt_confirms already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	ct-rabbit_mqtt_confirms \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_mqtt_confirms
	fi
	- name: CT reader
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-reader ]]; then
	echo "ct-reader already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	ct-reader \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-reader
	fi
	- name: CT retainer
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-retainer ]]; then
	echo "ct-retainer already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	ct-retainer \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-retainer
	fi
	- name: CT shared
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-shared ]]; then
	echo "ct-shared already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	ct-shared \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-shared
	fi
	- name: CT util
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-util ]]; then
	echo "ct-util already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	ct-util \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-util
	fi
	- name: CT v5
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-v5 ]]; then
	echo "ct-v5 already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_mqtt \
	ct-v5 \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-v5
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_mqtt-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_mqtt-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_mqtt/logs/*
	test-rabbitmq_peer_discovery_aws:
	name: Test rabbitmq_peer_discovery_aws
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_peer_discovery_aws/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_aws \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_aws \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_aws \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT config_schema
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-config_schema ]]; then
	echo "ct-config_schema already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_aws \
	ct-config_schema \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-config_schema
	fi
	- name: CT integration
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-integration ]]; then
	echo "ct-integration already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_aws \
	ct-integration \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-integration
	fi
	- name: CT unit
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit ]]; then
	echo "ct-unit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_aws \
	ct-unit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_peer_discovery_aws-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_peer_discovery_aws-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_peer_discovery_aws/logs/*
	test-rabbitmq_peer_discovery_common:
	name: Test rabbitmq_peer_discovery_common
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_peer_discovery_common/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_common \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_common \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_common \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT config_schema
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-config_schema ]]; then
	echo "ct-config_schema already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_common \
	ct-config_schema \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-config_schema
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_peer_discovery_common-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_peer_discovery_common-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_peer_discovery_common/logs/*
	test-rabbitmq_peer_discovery_consul:
	name: Test rabbitmq_peer_discovery_consul
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_peer_discovery_consul/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_consul \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_consul \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_consul \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT config_schema
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-config_schema ]]; then
	echo "ct-config_schema already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_consul \
	ct-config_schema \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-config_schema
	fi
	- name: CT rabbitmq_peer_discovery_consul
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbitmq_peer_discovery_consul ]]; then
	echo "ct-rabbitmq_peer_discovery_consul already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_consul \
	ct-rabbitmq_peer_discovery_consul \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbitmq_peer_discovery_consul
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_peer_discovery_consul-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_peer_discovery_consul-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_peer_discovery_consul/logs/*
	test-rabbitmq_peer_discovery_etcd:
	name: Test rabbitmq_peer_discovery_etcd
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_peer_discovery_etcd/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_etcd \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_etcd \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_etcd \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT config_schema
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-config_schema ]]; then
	echo "ct-config_schema already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_etcd \
	ct-config_schema \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-config_schema
	fi
	- name: CT system
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-system ]]; then
	echo "ct-system already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_etcd \
	ct-system \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-system
	fi
	- name: CT unit
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit ]]; then
	echo "ct-unit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_etcd \
	ct-unit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_peer_discovery_etcd-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_peer_discovery_etcd-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_peer_discovery_etcd/logs/*
	test-rabbitmq_peer_discovery_k8s:
	name: Test rabbitmq_peer_discovery_k8s
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_peer_discovery_k8s/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_k8s \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_k8s \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_k8s \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT config_schema
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-config_schema ]]; then
	echo "ct-config_schema already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_k8s \
	ct-config_schema \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-config_schema
	fi
	- name: CT rabbitmq_peer_discovery_k8s
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbitmq_peer_discovery_k8s ]]; then
	echo "ct-rabbitmq_peer_discovery_k8s already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_peer_discovery_k8s \
	ct-rabbitmq_peer_discovery_k8s \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbitmq_peer_discovery_k8s
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_peer_discovery_k8s-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_peer_discovery_k8s-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_peer_discovery_k8s/logs/*
	test-rabbitmq_prelaunch:
	name: Test rabbitmq_prelaunch
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_prelaunch/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_prelaunch \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_prelaunch \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_prelaunch \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT rabbit_logger_std_h
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_logger_std_h ]]; then
	echo "ct-rabbit_logger_std_h already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_prelaunch \
	ct-rabbit_logger_std_h \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_logger_std_h
	fi
	- name: CT rabbit_prelaunch_file
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_prelaunch_file ]]; then
	echo "ct-rabbit_prelaunch_file already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_prelaunch \
	ct-rabbit_prelaunch_file \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_prelaunch_file
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_prelaunch-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_prelaunch-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_prelaunch/logs/*
	test-rabbitmq_prometheus:
	name: Test rabbitmq_prometheus
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_prometheus/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_prometheus \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_prometheus \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_prometheus \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT config_schema
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-config_schema ]]; then
	echo "ct-config_schema already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_prometheus \
	ct-config_schema \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-config_schema
	fi
	- name: CT prometheus_rabbitmq_federation_collector
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-prometheus_rabbitmq_federation_collector ]]; then
	echo "ct-prometheus_rabbitmq_federation_collector already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_prometheus \
	ct-prometheus_rabbitmq_federation_collector \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-prometheus_rabbitmq_federation_collector
	fi
	- name: CT rabbit_prometheus_http
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_prometheus_http ]]; then
	echo "ct-rabbit_prometheus_http already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_prometheus \
	ct-rabbit_prometheus_http \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_prometheus_http
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_prometheus-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_prometheus-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_prometheus/logs/*
	test-rabbitmq_random_exchange:
	name: Test rabbitmq_random_exchange
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_random_exchange/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_random_exchange \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_random_exchange \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_random_exchange \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_random_exchange-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_random_exchange-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_random_exchange/logs/*
	test-rabbitmq_recent_history_exchange:
	name: Test rabbitmq_recent_history_exchange
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_recent_history_exchange/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_recent_history_exchange \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_recent_history_exchange \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_recent_history_exchange \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT system
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-system ]]; then
	echo "ct-system already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_recent_history_exchange \
	ct-system \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-system
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_recent_history_exchange-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_recent_history_exchange-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_recent_history_exchange/logs/*
	test-rabbitmq_sharding:
	name: Test rabbitmq_sharding
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_sharding/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_sharding \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_sharding \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_sharding \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT rabbit_hash_exchange
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_hash_exchange ]]; then
	echo "ct-rabbit_hash_exchange already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_sharding \
	ct-rabbit_hash_exchange \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_hash_exchange
	fi
	- name: CT rabbit_sharding
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_sharding ]]; then
	echo "ct-rabbit_sharding already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_sharding \
	ct-rabbit_sharding \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_sharding
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_sharding-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_sharding-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_sharding/logs/*
	test-rabbitmq_shovel:
	name: Test rabbitmq_shovel
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_shovel/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_shovel \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_shovel \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_shovel \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT amqp10
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-amqp10 ]]; then
	echo "ct-amqp10 already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_shovel \
	ct-amqp10 \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-amqp10
	fi
	- name: CT amqp10_dynamic
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-amqp10_dynamic ]]; then
	echo "ct-amqp10_dynamic already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_shovel \
	ct-amqp10_dynamic \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-amqp10_dynamic
	fi
	- name: CT amqp10_shovel
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-amqp10_shovel ]]; then
	echo "ct-amqp10_shovel already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_shovel \
	ct-amqp10_shovel \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-amqp10_shovel
	fi
	- name: CT config
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-config ]]; then
	echo "ct-config already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_shovel \
	ct-config \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-config
	fi
	- name: CT configuration
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-configuration ]]; then
	echo "ct-configuration already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_shovel \
	ct-configuration \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-configuration
	fi
	- name: CT delete_shovel_command
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-delete_shovel_command ]]; then
	echo "ct-delete_shovel_command already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_shovel \
	ct-delete_shovel_command \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-delete_shovel_command
	fi
	- name: CT dynamic
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-dynamic ]]; then
	echo "ct-dynamic already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_shovel \
	ct-dynamic \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-dynamic
	fi
	- name: CT parameters
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-parameters ]]; then
	echo "ct-parameters already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_shovel \
	ct-parameters \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-parameters
	fi
	- name: CT rolling_upgrade
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rolling_upgrade ]]; then
	echo "ct-rolling_upgrade already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_shovel \
	ct-rolling_upgrade \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rolling_upgrade
	fi
	- name: CT shovel_status_command
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-shovel_status_command ]]; then
	echo "ct-shovel_status_command already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_shovel \
	ct-shovel_status_command \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-shovel_status_command
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_shovel-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_shovel-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_shovel/logs/*
	test-rabbitmq_shovel_management:
	name: Test rabbitmq_shovel_management
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_shovel_management/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_shovel_management \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_shovel_management \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_shovel_management \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT http
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-http ]]; then
	echo "ct-http already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_shovel_management \
	ct-http \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-http
	fi
	- name: CT rabbit_shovel_mgmt
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_shovel_mgmt ]]; then
	echo "ct-rabbit_shovel_mgmt already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_shovel_management \
	ct-rabbit_shovel_mgmt \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_shovel_mgmt
	fi
	- name: CT rabbit_shovel_mgmt_util
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_shovel_mgmt_util ]]; then
	echo "ct-rabbit_shovel_mgmt_util already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_shovel_management \
	ct-rabbit_shovel_mgmt_util \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_shovel_mgmt_util
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_shovel_management-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_shovel_management-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_shovel_management/logs/*
	test-rabbitmq_stomp:
	name: Test rabbitmq_stomp
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_stomp/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stomp \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stomp \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stomp \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT command
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-command ]]; then
	echo "ct-command already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stomp \
	ct-command \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-command
	fi
	- name: CT config_schema
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-config_schema ]]; then
	echo "ct-config_schema already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stomp \
	ct-config_schema \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-config_schema
	fi
	- name: CT connections
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-connections ]]; then
	echo "ct-connections already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stomp \
	ct-connections \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-connections
	fi
	- name: CT frame
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-frame ]]; then
	echo "ct-frame already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stomp \
	ct-frame \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-frame
	fi
	- name: CT proxy_protocol
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-proxy_protocol ]]; then
	echo "ct-proxy_protocol already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stomp \
	ct-proxy_protocol \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-proxy_protocol
	fi
	- name: CT python
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-python ]]; then
	echo "ct-python already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stomp \
	ct-python \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-python
	fi
	- name: CT system
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-system ]]; then
	echo "ct-system already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stomp \
	ct-system \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-system
	fi
	- name: CT topic
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-topic ]]; then
	echo "ct-topic already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stomp \
	ct-topic \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-topic
	fi
	- name: CT util
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-util ]]; then
	echo "ct-util already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stomp \
	ct-util \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-util
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_stomp-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_stomp-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_stomp/logs/*
	test-rabbitmq_stream:
	name: Test rabbitmq_stream
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_stream/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stream \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stream \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stream \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT commands
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-commands ]]; then
	echo "ct-commands already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stream \
	ct-commands \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-commands
	fi
	- name: CT config_schema
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-config_schema ]]; then
	echo "ct-config_schema already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stream \
	ct-config_schema \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-config_schema
	fi
	- name: CT protocol_interop
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-protocol_interop ]]; then
	echo "ct-protocol_interop already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stream \
	ct-protocol_interop \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-protocol_interop
	fi
	- name: CT rabbit_stream
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_stream ]]; then
	echo "ct-rabbit_stream already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stream \
	ct-rabbit_stream \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_stream
	fi
	- name: CT rabbit_stream_manager
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_stream_manager ]]; then
	echo "ct-rabbit_stream_manager already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stream \
	ct-rabbit_stream_manager \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_stream_manager
	fi
	- name: CT rabbit_stream_reader
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_stream_reader ]]; then
	echo "ct-rabbit_stream_reader already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stream \
	ct-rabbit_stream_reader \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_stream_reader
	fi
	- name: CT rabbit_stream_utils
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_stream_utils ]]; then
	echo "ct-rabbit_stream_utils already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stream \
	ct-rabbit_stream_utils \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_stream_utils
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_stream-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_stream-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_stream/logs/*
	test-rabbitmq_stream_management:
	name: Test rabbitmq_stream_management
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_stream_management/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stream_management \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stream_management \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stream_management \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT http
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-http ]]; then
	echo "ct-http already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_stream_management \
	ct-http \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-http
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_stream_management-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_stream_management-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_stream_management/logs/*
	test-rabbitmq_top:
	name: Test rabbitmq_top
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_top/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_top \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_top \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_top \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_top-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_top-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_top/logs/*
	test-rabbitmq_tracing:
	name: Test rabbitmq_tracing
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_tracing/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_tracing \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_tracing \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_tracing \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT rabbit_tracing
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_tracing ]]; then
	echo "ct-rabbit_tracing already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_tracing \
	ct-rabbit_tracing \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_tracing
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_tracing-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_tracing-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_tracing/logs/*
	test-rabbitmq_trust_store:
	name: Test rabbitmq_trust_store
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_trust_store/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_trust_store \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_trust_store \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_trust_store \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT config_schema
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-config_schema ]]; then
	echo "ct-config_schema already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_trust_store \
	ct-config_schema \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-config_schema
	fi
	- name: CT system
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-system ]]; then
	echo "ct-system already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_trust_store \
	ct-system \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-system
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_trust_store-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_trust_store-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_trust_store/logs/*
	test-rabbitmq_web_dispatch:
	name: Test rabbitmq_web_dispatch
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_web_dispatch/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_dispatch \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_dispatch \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_dispatch \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT rabbit_web_dispatch
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_web_dispatch ]]; then
	echo "ct-rabbit_web_dispatch already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_dispatch \
	ct-rabbit_web_dispatch \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_web_dispatch
	fi
	- name: CT rabbit_web_dispatch_unit
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-rabbit_web_dispatch_unit ]]; then
	echo "ct-rabbit_web_dispatch_unit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_dispatch \
	ct-rabbit_web_dispatch_unit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-rabbit_web_dispatch_unit
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_web_dispatch-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_web_dispatch-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_web_dispatch/logs/*
	test-rabbitmq_web_mqtt:
	name: Test rabbitmq_web_mqtt
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_web_mqtt/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_mqtt \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_mqtt \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_mqtt \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT command
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-command ]]; then
	echo "ct-command already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_mqtt \
	ct-command \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-command
	fi
	- name: CT config_schema
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-config_schema ]]; then
	echo "ct-config_schema already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_mqtt \
	ct-config_schema \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-config_schema
	fi
	- name: CT proxy_protocol
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-proxy_protocol ]]; then
	echo "ct-proxy_protocol already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_mqtt \
	ct-proxy_protocol \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-proxy_protocol
	fi
	- name: CT system
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-system ]]; then
	echo "ct-system already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_mqtt \
	ct-system \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-system
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_web_mqtt-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_web_mqtt-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_web_mqtt/logs/*
	test-rabbitmq_web_mqtt_examples:
	name: Test rabbitmq_web_mqtt_examples
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_web_mqtt_examples/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_mqtt_examples \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_mqtt_examples \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_mqtt_examples \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_web_mqtt_examples-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_web_mqtt_examples-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_web_mqtt_examples/logs/*
	test-rabbitmq_web_stomp:
	name: Test rabbitmq_web_stomp
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_web_stomp/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_stomp \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_stomp \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_stomp \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: CT amqp_stomp
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-amqp_stomp ]]; then
	echo "ct-amqp_stomp already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_stomp \
	ct-amqp_stomp \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-amqp_stomp
	fi
	- name: CT config_schema
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-config_schema ]]; then
	echo "ct-config_schema already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_stomp \
	ct-config_schema \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-config_schema
	fi
	- name: CT cowboy_websocket
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-cowboy_websocket ]]; then
	echo "ct-cowboy_websocket already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_stomp \
	ct-cowboy_websocket \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-cowboy_websocket
	fi
	- name: CT proxy_protocol
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-proxy_protocol ]]; then
	echo "ct-proxy_protocol already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_stomp \
	ct-proxy_protocol \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-proxy_protocol
	fi
	- name: CT raw_websocket
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-raw_websocket ]]; then
	echo "ct-raw_websocket already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_stomp \
	ct-raw_websocket \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-raw_websocket
	fi
	- name: CT unit
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/ct-unit ]]; then
	echo "ct-unit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_stomp \
	ct-unit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/ct-unit
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_web_stomp-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_web_stomp-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_web_stomp/logs/*
	test-rabbitmq_web_stomp_examples:
	name: Test rabbitmq_web_stomp_examples
	needs:
	- load-test-result-cache
	- test-rabbitmq_cli
	runs-on: ubuntu-20.04
	strategy:
	fail-fast: false
	matrix:
	otp_version:
	- 26.2
	metadata_store:
	- mnesia
	- khepri
	timeout-minutes: 180
	env:
	SUCCESS_PATH: /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}/rabbitmq_web_stomp_examples/${{ matrix.metadata_store }}/${{ matrix.otp_version }}
	steps:
	- name: FETCH TEST RESULT CACHE
	uses: actions/download-artifact@v4
	with:
	name: test-result-cache-subdir
	path: /home/runner/test-result-cache
	- name: CHECKOUT REPOSITORY
	uses: actions/checkout@v4
	- name: SETUP ERLANG/ELIXIR
	uses: erlef/setup-beam@v1
	with:
	otp-version: ${{ matrix.otp_version }}
	elixir-version: 1.15
	- name: BUILD
	run: \|
	make \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	mkdir -p ${{ env.SUCCESS_PATH }}
	- name: XREF
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/xref ]]; then
	echo "xref already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_stomp_examples \
	xref \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/xref
	fi
	- name: DIALYZE
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/dialyze ]]; then
	echo "dialyze already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_stomp_examples \
	dialyze \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/dialyze
	fi
	continue-on-error: false
	- name: EUNIT
	run: \|
	if [[ -f ${{ env.SUCCESS_PATH }}/eunit ]]; then
	echo "eunit already passed for this key ${{ needs.load-test-result-cache.outputs.hash }}"
	else
	make -C deps/rabbitmq_web_stomp_examples \
	eunit \
	RABBITMQ_METADATA_STORE=${{ matrix.metadata_store }}
	touch ${{ env.SUCCESS_PATH }}/eunit
	fi
	- name: SAVE CACHE COPY
	uses: actions/[email protected]
	with:
	name: trc-rabbitmq_web_stomp_examples-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: \|
	/home/runner/test-result-cache
	- name: UPLOAD TEST ARTIFACTS
	if: always()
	uses: actions/[email protected]
	with:
	name: testlogs-rabbitmq_web_stomp_examples-${{ matrix.metadata_store }}-${{ matrix.otp_version }}
	path: deps/rabbitmq_web_stomp_examples/logs/*
	summary-test-make:
	if: always()
	needs:
	- load-test-result-cache
	- test-rabbit
	- test-rabbitmq_cli
	- test-amqp10_client
	- test-amqp10_common
	- test-amqp_client
	- test-oauth2_client
	- test-rabbit_common
	- test-rabbitmq_ct_client_helpers
	- test-rabbitmq_ct_helpers
	- test-rabbitmq_stream_common
	- test-trust_store_http
	- test-rabbitmq_amqp_client
	- test-rabbitmq_amqp1_0
	- test-rabbitmq_auth_backend_cache
	- test-rabbitmq_auth_backend_http
	- test-rabbitmq_auth_backend_ldap
	- test-rabbitmq_auth_backend_oauth2
	- test-rabbitmq_auth_mechanism_ssl
	- test-rabbitmq_aws
	- test-rabbitmq_consistent_hash_exchange
	- test-rabbitmq_event_exchange
	- test-rabbitmq_federation
	- test-rabbitmq_federation_management
	- test-rabbitmq_jms_topic_exchange
	- test-rabbitmq_management
	- test-rabbitmq_management_agent
	- test-rabbitmq_mqtt
	- test-rabbitmq_peer_discovery_aws
	- test-rabbitmq_peer_discovery_common
	- test-rabbitmq_peer_discovery_consul
	- test-rabbitmq_peer_discovery_etcd
	- test-rabbitmq_peer_discovery_k8s
	- test-rabbitmq_prelaunch
	- test-rabbitmq_prometheus
	- test-rabbitmq_random_exchange
	- test-rabbitmq_recent_history_exchange
	- test-rabbitmq_sharding
	- test-rabbitmq_shovel
	- test-rabbitmq_shovel_management
	- test-rabbitmq_stomp
	- test-rabbitmq_stream
	- test-rabbitmq_stream_management
	- test-rabbitmq_top
	- test-rabbitmq_tracing
	- test-rabbitmq_trust_store
	- test-rabbitmq_web_dispatch
	- test-rabbitmq_web_mqtt
	- test-rabbitmq_web_mqtt_examples
	- test-rabbitmq_web_stomp
	- test-rabbitmq_web_stomp_examples
	runs-on: ubuntu-latest
	steps:
	- name: MOUNT TEST RESULT CACHE
	uses: actions/[email protected]
	with:
	path: /home/runner/test-result-cache/
	key: ${{ runner.os }}-test-result-cache-${{ needs.load-test-result-cache.outputs.hash }}
	restore-keys: \|
	${{ runner.os }}-test-result-cache-
	fail-on-cache-miss: true
	save-always: true
	- name: UPDATE CACHE
	uses: actions/download-artifact@v4
	with:
	pattern: trc-*
	path: /home/runner/test-result-cache
	merge-multiple: true
	- name: PRINT RESULTS
	run: \|
	set -x
	tree /home/runner/test-result-cache/${{ needs.load-test-result-cache.outputs.hash }}
	- name: SUMMARY
	run: \|
	cat << 'EOF' \| jq -e 'map(.result == "success") \| all(.)'
	${{ toJson(needs) }}
	EOF

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Add the simplest CI with make #47

Workflow file

Add the simplest CI with make #47

Jobs

Run details

Workflow file for this run