Update screenshots for images via script #1

Workflow file for this run

.github/workflows/image_run_pr_v3.yml at 8144d3c


	name: Image Creation PR Run

	on:

	pull_request:
	branches:
	- main

	workflow_dispatch:

	permissions: read-all

	jobs:
	airflow:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py airflow airflow/airflow/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run airflow/airflow/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/airflow": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	airflow-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py airflow-ib airflow/airflow/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run airflow/airflow/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/airflow-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	airflow-ib-bitnami:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py airflow-ib-bitnami airflow/airflow/bitnami-ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run airflow/airflow/bitnami-ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/airflow-ib-bitnami": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	alertmanager-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py alertmanager-ib alertmanager/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run alertmanager/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/alertmanager-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	alloy-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py alloy-ib alloy/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run alloy/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/alloy-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	ansible-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py ansible-ib ansible/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run ansible/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/ansible-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	ansible-lint-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py ansible-lint-ib ansible-lint/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run ansible-lint/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/ansible-lint-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	ansible-operator-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py ansible-operator-ib ansible-operator/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run ansible-operator/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/ansible-operator-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	apache:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py apache apache/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run apache/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/apache": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	apache-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py apache-ib apache/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run apache/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/apache2-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	apache-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py apache-official apache/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run apache/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/apache-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	argocd:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py argocd argocd/quay output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run argocd/quay


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/argocd": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	argocd-bigbang-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py argocd-bigbang-ib argocd/bigbang-ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run argocd/bigbang-ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/argocd-bigbang-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	argocd-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py argocd-ib argocd/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run argocd/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/argocd-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	auditbeat-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py auditbeat-ib auditbeat/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run auditbeat/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/auditbeat-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	bats-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py bats-ib bats/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run bats/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/bats-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	blackbox-exporter-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py blackbox-exporter-ib blackbox-exporter/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run blackbox-exporter/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/blackbox-exporter-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	boundary-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py boundary-ib boundary/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run boundary/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/boundary-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	buildah-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py buildah-ib buildah/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run buildah/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/buildah-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	camel-k-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py camel-k-ib camel-k/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run camel-k/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/camel-k-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	cass-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py cass-ib cass/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run cass/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/cass-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	cassandra-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py cassandra-official cassandra/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run cassandra/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/cassandra-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	ceph-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py ceph-ib ceph/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run ceph/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/ceph-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	certtool-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py certtool-ib certtool/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run certtool/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/certtool-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	chart-testing-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py chart-testing-ib chart-testing/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run chart-testing/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/chart-testing-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	clickhouse-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py clickhouse-ib clickhouse/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run clickhouse/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/clickhouse-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	cockroachdb-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py cockroachdb-ib cockroachdb/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run cockroachdb/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/cockroachdb-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	consul:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py consul consul/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run consul/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/consul": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	consul-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py consul-ib consul/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run consul/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/consul-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	consul-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py consul-official consul/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run consul/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/consul-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	coredns-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py coredns-ib coredns/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run coredns/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/coredns-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	couchdb:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py couchdb couchdb/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run couchdb/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/couchdb": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	couchdb-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py couchdb-ib couchdb/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run couchdb/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/couchdb_3-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	couchdb-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py couchdb-official couchdb/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run couchdb/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/couchdb-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	curl:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py curl curl/curlimages output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run curl/curlimages


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/curl": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	dex-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py dex-ib dex/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run dex/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/dex-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	eck-operator-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py eck-operator-ib eck-operator/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run eck-operator/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/eck-operator-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	elasticsearch:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py elasticsearch elasticsearch/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run elasticsearch/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/elasticsearch": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	elasticsearch-dump-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py elasticsearch-dump-ib elasticsearch-dump/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run elasticsearch-dump/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/elasticsearch-dump-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	elasticsearch-exporter-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py elasticsearch-exporter-ib elasticsearch-exporter/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run elasticsearch-exporter/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/elasticsearch-exporter-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	elasticsearch-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py elasticsearch-official elasticsearch/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run elasticsearch/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/elasticsearch-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	envoy:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py envoy envoy/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run envoy/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/envoy": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	envoy-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py envoy-official envoy/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run envoy/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/envoy-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	etcd:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py etcd etcd/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run etcd/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/etcd": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	etcd-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py etcd-ib etcd/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run etcd/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/etcd-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	filebeat-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py filebeat-ib filebeat/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run filebeat/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/filebeat-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	fluent-bit:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py fluent-bit fluent-bit/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run fluent-bit/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/fluent-bit": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	fluent-bit-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py fluent-bit-ib fluent-bit/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run fluent-bit/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/fluent-bit-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	fluent-bit-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py fluent-bit-official fluent-bit/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run fluent-bit/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/fluent-bit-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	fluentd:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py fluentd fluentd/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run fluentd/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/fluentd": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	fluentd-elasticsearch-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py fluentd-elasticsearch-ib fluentd-elasticsearch/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run fluentd-elasticsearch/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/fluentd-elasticsearch-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	fluentd-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py fluentd-ib fluentd/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run fluentd/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/fluentd-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	fluentd-kubernetes-daemonset-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py fluentd-kubernetes-daemonset-ib fluentd-kubernetes-daemonset/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run fluentd-kubernetes-daemonset/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/fluentd-kubernetes-daemonset-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	fluentd-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py fluentd-official fluentd/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run fluentd/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/fluentd-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	fluxcd-helm-controller-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py fluxcd-helm-controller-ib fluxcd-helm-controller/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run fluxcd-helm-controller/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/fluxcd-helm-controller-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	fluxcd-image-automation-controller-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py fluxcd-image-automation-controller-ib fluxcd-image-automation-controller/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run fluxcd-image-automation-controller/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/fluxcd-image-automation-controller-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	fluxcd-image-reflector-controller-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py fluxcd-image-reflector-controller-ib fluxcd-image-reflector-controller/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run fluxcd-image-reflector-controller/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/fluxcd-image-reflector-controller-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	fluxcd-kustomize-controller-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py fluxcd-kustomize-controller-ib fluxcd-kustomize-controller/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run fluxcd-kustomize-controller/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/fluxcd-kustomize-controller-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	fluxcd-notification-controller-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py fluxcd-notification-controller-ib fluxcd-notification-controller/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run fluxcd-notification-controller/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/fluxcd-notification-controller-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	fluxcd-source-controller-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py fluxcd-source-controller-ib fluxcd-source-controller/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run fluxcd-source-controller/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/fluxcd-source-controller-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	gatekeeper-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py gatekeeper-ib gatekeeper/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run gatekeeper/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/gatekeeper-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	ghost:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py ghost ghost/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run ghost/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/ghost": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	git-lfs-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py git-lfs-ib git-lfs/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run git-lfs/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/git-lfs-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	gitaly-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py gitaly-ib gitaly/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run gitaly/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/gitaly-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	gitlab-certificates-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py gitlab-certificates-ib gitlab-certificates/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run gitlab-certificates/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/gitlab-certificates-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	gitlab-cfssl-self-sign-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py gitlab-cfssl-self-sign-ib gitlab-cfssl-self-sign/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run gitlab-cfssl-self-sign/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/gitlab-cfssl-self-sign-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	gitlab-container-registry-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py gitlab-container-registry-ib gitlab-container-registry/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run gitlab-container-registry/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/gitlab-container-registry-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	gitlab-exporter-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py gitlab-exporter-ib gitlab-exporter/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run gitlab-exporter/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/gitlab-exporter-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	gitlab-kas-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py gitlab-kas-ib gitlab-kas/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run gitlab-kas/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/gitlab-kas-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	gitlab-runner-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py gitlab-runner-ib gitlab-runner/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run gitlab-runner/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/gitlab-runner-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	gitlab-shell-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py gitlab-shell-ib gitlab-shell/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run gitlab-shell/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/gitlab-shell-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	gitlab-workhorse-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py gitlab-workhorse-ib gitlab-workhorse/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run gitlab-workhorse/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/gitlab-workhorse-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	grafana-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py grafana-ib grafana/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run grafana/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/grafana-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	grafana-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py grafana-official grafana/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run grafana/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/grafana-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	grafana-plugins-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py grafana-plugins-ib grafana-plugins/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run grafana-plugins/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/grafana-plugins-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	hadolint-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py hadolint-ib hadolint/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run hadolint/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/hadolint-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	haproxy:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py haproxy haproxy/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run haproxy/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/haproxy": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	haproxy-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py haproxy-ib haproxy/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run haproxy/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/haproxy24-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	haproxy-latest-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py haproxy-latest-ib haproxy-latest/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run haproxy-latest/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/haproxy-latest-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	haproxy-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py haproxy-official haproxy/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run haproxy/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/haproxy-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	heartbeat-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py heartbeat-ib heartbeat/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run heartbeat/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/heartbeat-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	influxdb:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py influxdb influxdb/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run influxdb/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/influxdb": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	jmx-exporter-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py jmx-exporter-ib jmx-exporter/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run jmx-exporter/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/jmx-exporter-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	jq-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py jq-ib jq/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run jq/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/jq-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	k6-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py k6-ib k6/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run k6/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/k6-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	k8s-sidecar-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py k8s-sidecar-ib k8s-sidecar/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run k8s-sidecar/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/k8s-sidecar-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	k8s-sidecar-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py k8s-sidecar-official k8s-sidecar/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run k8s-sidecar/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/k8s-sidecar-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	kafka-bridge-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py kafka-bridge-ib kafka-bridge/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run kafka-bridge/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/kafka-bridge-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	kafka-exporter-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py kafka-exporter-ib kafka-exporter/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run kafka-exporter/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/kafka-exporter-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	kafka-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py kafka-ib kafka/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run kafka/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/kafka-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	keycloak-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py keycloak-official keycloak/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run keycloak/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/keycloak-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	kibana-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py kibana-ib kibana/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run kibana/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/kibana-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	kong:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py kong kong/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run kong/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/kong": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	kongkic-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py kongkic-ib kongkic/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run kongkic/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/kongkic-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	kube-webhook-certgen-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py kube-webhook-certgen-ib kube-webhook-certgen/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run kube-webhook-certgen/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/kube-webhook-certgen-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	kubectl-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py kubectl-ib kubectl/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run kubectl/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/kubectl-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	kyverno-background-controller-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py kyverno-background-controller-ib kyverno-background-controller/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run kyverno-background-controller/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/kyverno-background-controller-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	kyverno-cleanup-controller-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py kyverno-cleanup-controller-ib kyverno-cleanup-controller/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run kyverno-cleanup-controller/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/kyverno-cleanup-controller-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	kyverno-reports-controller-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py kyverno-reports-controller-ib kyverno-reports-controller/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run kyverno-reports-controller/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/kyverno-reports-controller-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	logstash-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py logstash-ib logstash/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run logstash/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/logstash-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	mariadb:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py mariadb mariadb/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run mariadb/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/mariadb": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	mariadb-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py mariadb-ib mariadb/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run mariadb/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/mariadb-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	mariadb-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py mariadb-official mariadb/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run mariadb/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/mariadb-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	mc-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py mc-ib mc/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run mc/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/mc-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	memcached:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py memcached memcached/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run memcached/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/memcached": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	memcached-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py memcached-ib memcached/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run memcached/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/memcached-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	memcached-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py memcached-official memcached/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run memcached/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/memcached-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	metabase-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py metabase-ib metabase/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run metabase/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/metabase-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	metricbeat-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py metricbeat-ib metricbeat/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run metricbeat/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/metricbeat-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	metrics-server-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py metrics-server-ib metrics-server/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run metrics-server/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/metrics-server-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	microsoft-sql-server-2019-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py microsoft-sql-server-2019-ib microsoft-sql-server-2019/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run microsoft-sql-server-2019/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/microsoft-sql-server-2019-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	minio-console-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py minio-console-ib minio-console/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run minio-console/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/minio-console-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	minio-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py minio-ib minio/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run minio/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/minio-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	minio-operator-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py minio-operator-ib minio-operator/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run minio-operator/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/minio-operator-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	minio-operator-sidecar-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py minio-operator-sidecar-ib minio-operator-sidecar/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run minio-operator-sidecar/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/minio-operator-sidecar-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	mkdocs-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py mkdocs-ib mkdocs/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run mkdocs/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/mkdocs-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	molecule-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py molecule-ib molecule/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run molecule/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/molecule-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	mongodb:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py mongodb mongodb/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run mongodb/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/mongodb": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	mongodb-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py mongodb-ib mongodb/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run mongodb/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/mongodb-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	mongodb-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py mongodb-official mongodb/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run mongodb/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/mongodb-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	moodle-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py moodle-ib moodle/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run moodle/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/moodle-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	mysql:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py mysql mysql/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run mysql/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/mysql": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	mysql-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py mysql-ib mysql/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run mysql/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/mysql8-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	mysql-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py mysql-official mysql/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run mysql/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/mysql-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	nats:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py nats nats/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run nats/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/nats": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	nats-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py nats-ib nats/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run nats/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/nats-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	nats-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py nats-official nats/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run nats/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/nats-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	nginx:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py nginx nginx/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run nginx/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/nginx": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	nginx-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py nginx-ib nginx/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run nginx/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/nginx-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	nginx-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py nginx-official nginx/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run nginx/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/nginx-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	nifi-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py nifi-ib nifi/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run nifi/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/nifi-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	nifi-registry-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py nifi-registry-ib nifi-registry/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run nifi-registry/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/nifi-registry-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	node-exporter:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py node-exporter node-exporter/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run node-exporter/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/node-exporter": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	node-exporter-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py node-exporter-ib node-exporter/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run node-exporter/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/node-exporter-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	node-exporter-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py node-exporter-official node-exporter/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run node-exporter/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/node-exporter-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	oncall:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py oncall oncall/grafana output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run oncall/grafana


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/oncall": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	opa-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py opa-ib opa/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run opa/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/opa-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	openldap-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py openldap-ib openldap/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run openldap/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/openldap-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	osee-postgres-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py osee-postgres-ib osee-postgres/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run osee-postgres/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/osee-postgres-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	packetbeat-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py packetbeat-ib packetbeat/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run packetbeat/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/packetbeat-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	pause-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py pause-ib pause/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run pause/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/pause-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	pgadmin-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py pgadmin-ib pgadmin/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run pgadmin/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/pgadmin-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	podman-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py podman-ib podman/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run podman/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/podman-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	postfix-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py postfix-ib postfix/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run postfix/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/postfix-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	postgres-exporter-bitnami-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py postgres-exporter-bitnami-ib postgres-exporter/bitnami-ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run postgres-exporter/bitnami-ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/postgres-exporter-bitnami-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	postgres-exporter-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py postgres-exporter-ib postgres-exporter/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run postgres-exporter/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/postgres-exporter-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	postgresql:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py postgresql postgresql/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run postgresql/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/postgresql": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	postgresql-bitnami-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py postgresql-bitnami-ib postgresql/bitnami-ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run postgresql/bitnami-ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/postgresql-bitnami-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	postgresql-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py postgresql-ib postgresql/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run postgresql/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/postgresql12-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	postgresql-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py postgresql-official postgresql/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run postgresql/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/postgresql-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	prometheus:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py prometheus prometheus/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run prometheus/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/prometheus": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	prometheus-config-reloader-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py prometheus-config-reloader-ib prometheus-config-reloader/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run prometheus-config-reloader/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/prometheus-config-reloader-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	prometheus-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py prometheus-ib prometheus/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run prometheus/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/prometheus-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	prometheus-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py prometheus-official prometheus/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run prometheus/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/prometheus-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	prometheus-operator-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py prometheus-operator-ib prometheus-operator/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run prometheus-operator/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/prometheus-operator-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	rabbitmq:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py rabbitmq rabbitmq/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run rabbitmq/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/rabbitmq": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	rabbitmq-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py rabbitmq-official rabbitmq/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run rabbitmq/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/rabbitmq-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	redis:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py redis redis/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run redis/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/redis": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	redis-cluster:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py redis-cluster redis-cluster/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run redis-cluster/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/redis-cluster": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	redis-exporter-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py redis-exporter-ib redis-exporter/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run redis-exporter/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/redis-exporter-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	redis-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py redis-ib redis/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run redis/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/redis6-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	redis-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py redis-official redis/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run redis/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/redis-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	redis-sentinel-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py redis-sentinel-ib redis-sentinel/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run redis-sentinel/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/redis-sentinel-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	registry-v2-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py registry-v2-ib registry-v2/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run registry-v2/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/registry-v2-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	shellcheck-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py shellcheck-ib shellcheck/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run shellcheck/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/shellcheck-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	skopeo-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py skopeo-ib skopeo/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run skopeo/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/skopeo-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	solr-8-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py solr-8-ib solr-8/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run solr-8/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/solr-8-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	sqlite-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py sqlite-ib sqlite/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run sqlite/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/sqlite-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	telegraf:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py telegraf telegraf/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run telegraf/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/telegraf": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	tempo-query-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py tempo-query-ib tempo-query/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run tempo-query/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/tempo-query-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	terraform-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py terraform-ib terraform/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run terraform/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/terraform-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	terragrunt-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py terragrunt-ib terragrunt/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run terragrunt/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/terragrunt-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	tflint-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py tflint-ib tflint/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run tflint/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/tflint-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	thanos-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py thanos-ib thanos/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run thanos/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/thanos-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	tika-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py tika-ib tika/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run tika/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/tika-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	tomcat-openjdk11-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py tomcat-openjdk11-ib tomcat/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run tomcat/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/tomcat-openjdk11-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	tomcat10-openjdk17-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py tomcat10-openjdk17-ib tomcat10/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run tomcat10/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/tomcat10-openjdk17-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	tomcat9-openjdk11-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py tomcat9-openjdk11-ib tomcat9/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run tomcat9/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/tomcat9-openjdk11-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	traefik:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py traefik traefik/traefik output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run traefik/traefik


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/traefik": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	traefik-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py traefik-ib traefik/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run traefik/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/traefik-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	vale-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py vale-ib vale/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run vale/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/vale-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	vault:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py vault vault/hashicorp output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run vault/hashicorp


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/vault": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	vault-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py vault-ib vault/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run vault/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/vault-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	vault-k8s-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py vault-k8s-ib vault-k8s/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run vault-k8s/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/vault-k8s-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	vcluster-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py vcluster-ib vcluster/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run vcluster/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/vcluster-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	velero-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py velero-ib velero/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run velero/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/velero-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	wordpress:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py wordpress wordpress/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run wordpress/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/wordpress": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	wordpress-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py wordpress-ib wordpress/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run wordpress/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/wordpress-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	yourls:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py yourls yourls/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run yourls/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/yourls": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	yq-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py yq-ib yq/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run yq/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/yq-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	zeek-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py zeek-ib zeek/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run zeek/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/zeek-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	zookeeper:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py zookeeper zookeeper/bitnami output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run zookeeper/bitnami


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/zookeeper": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	zookeeper-ib:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py zookeeper-ib zookeeper/ironbank output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run zookeeper/ironbank


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/zookeeper-ib": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls
	zookeeper-official:
	runs-on: ubuntu-latest

	environment: actions-cicd-pr

	steps:
	- name: Import Coverage Tests
	uses: actions/checkout@v4
	with:
	repository: rapidfort/community-images-core
	token: ${{ secrets.COVERAGE_ACCESS_TOKEN }}


	- name: Check if test required
	id: test-required
	env:
	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	run: \|
	python3 scripts/tests_required.py zookeeper-official zookeeper/official output.txt
	cat output.txt >> $GITHUB_OUTPUT

	- name: Start minikube

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	with:
	memory: 6g
	driver: none
	uses: medyagh/setup-minikube@master
	- name: Check k8s cluster !

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: kubectl get pods -A
	- name: Setup ubuntu
	env:
	RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
	RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
	RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: ./scripts/github-pipelines/setup.sh

	- name: Set RF CLI Path
	run: echo "/home/runner/work/community-images/community-images" >> $GITHUB_PATH


	- name: Create images for testing PR
	env:
	DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
	DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
	RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
	IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
	IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
	if: ${{ steps.test-required.outputs.TEST_REQUIRED == 'yes' }}
	run: python3 community_images/common/orchestrator/main.py hourly_run zookeeper/official


	- name: Report pulls
	env:
	PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

	if: ${{ github.event_name == 'pull_request' && steps.test-required.outputs.TEST_REQUIRED == 'yes' }}

	run: \|
	curl -X POST \
	-H "Accept: application/json" \
	-H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
	-d '{ "rapidfort/zookeeper-official": 1 }' \
	https://data-receiver.rapidfort.com/counts/internal_image_pulls

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Update screenshots for images via script #1

Workflow file

Update screenshots for images via script #1

Jobs

Run details

Workflow file for this run