GitHub Actions: Regen workflows

2 files changed, 6488 insertions, 382 deletions

diff --git a/.github/workflows/test-erlang-otp-21.3.yaml b/.github/workflows/test-erlang-otp-21.3.yaml
index 2bc8733910..22029a7710 100644
--- a/.github/workflows/test-erlang-otp-21.3.yaml
+++ b/.github/workflows/test-erlang-otp-21.3.yaml
@@ -58,23 +58,32 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
       - name: PREPARE SECONDARY UMBRELLA COPIES
         if: success() && 'oldest' == 'oldest'
         run: |
+          # ----------------------------------------------------------
+          # CAUTION:
+          # The same script must be copied to `03-CT_SUITE.yaml`. It is used to
+          # recreate the umbrellas if the cache restore fails.
+          # ----------------------------------------------------------
           set -x
-          if ! test -f umbrellas/.ready; then
-            git config --global advice.detachedHead false
-            # We recreate the directory in case something incomplete was
-            # cached.
-            rm -rf umbrellas
-            mkdir -p umbrellas
-            git clone \
-              https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
-              umbrellas/master
-            make -C umbrellas/master co # To get RabbitMQ components.
-            for version in v3.7.x v3.8.3; do
-              umbrella="umbrellas/$version"
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
               # We copy the master Umbrella and checkout the appropriate tag.
               cp -a umbrellas/master "$umbrella"
               git -C "$umbrella" checkout "master"
@@ -87,10 +96,9 @@ jobs:
               make -C "$umbrella" up
               make -C "$umbrella/deps/rabbit" test-dist
               rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
-            done
-            rm -fr umbrellas/master
-            touch umbrellas/.ready
-          fi
+            fi
+          done
+          rm -fr umbrellas/master
   # vim:sw=2:et:
   eunit:
     needs: [checks]
@@ -158,14 +166,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-amqqueue_backward_compatibility \
@@ -224,14 +267,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-backing_queue \
@@ -290,14 +368,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-channel_interceptor \
@@ -356,14 +469,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-channel_operation_timeout \
@@ -422,14 +570,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-cluster \
@@ -488,14 +671,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-cluster_rename \
@@ -554,14 +772,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-clustering_management \
@@ -620,14 +873,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-config_schema \
@@ -686,14 +974,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-confirms_rejects \
@@ -752,14 +1075,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-consumer_timeout \
@@ -818,14 +1176,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-crashing_queues \
@@ -884,14 +1277,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-dead_lettering \
@@ -950,14 +1378,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-definition_import \
@@ -1016,14 +1479,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-disconnect_detected_during_alarm \
@@ -1082,14 +1580,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-dynamic_ha \
@@ -1148,14 +1681,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-dynamic_qq \
@@ -1214,14 +1782,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-eager_sync \
@@ -1280,14 +1883,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-feature_flags \
@@ -1346,14 +1984,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-health_check \
@@ -1412,14 +2085,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-lazy_queue \
@@ -1478,14 +2186,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-list_consumers_sanity_check \
@@ -1544,14 +2287,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-list_queues_online_and_offline \
@@ -1610,14 +2388,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-many_node_ha \
@@ -1676,14 +2489,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-message_size_limit \
@@ -1742,14 +2590,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-metrics \
@@ -1808,14 +2691,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-mirrored_supervisor \
@@ -1874,14 +2792,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-msg_store \
@@ -1940,14 +2893,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-peer_discovery_classic_config \
@@ -2006,14 +2994,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-peer_discovery_dns \
@@ -2072,14 +3095,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-per_user_connection_tracking \
@@ -2138,14 +3196,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-per_vhost_connection_limit \
@@ -2204,14 +3297,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-per_vhost_connection_limit_partitions \
@@ -2270,14 +3398,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-per_vhost_msg_store \
@@ -2336,14 +3499,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-per_vhost_queue_limit \
@@ -2402,14 +3600,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-policy \
@@ -2468,14 +3701,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-priority_queue \
@@ -2534,14 +3802,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-priority_queue_recovery \
@@ -2600,14 +3903,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-product_info \
@@ -2666,14 +4004,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-proxy_protocol \
@@ -2732,14 +4105,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-publisher_confirms_parallel \
@@ -2798,14 +4206,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-queue_length_limits \
@@ -2864,14 +4307,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-queue_master_location \
@@ -2930,14 +4408,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-queue_parallel \
@@ -2996,14 +4509,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-quorum_queue \
@@ -3062,14 +4610,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-rabbit_core_metrics_gc \
@@ -3128,14 +4711,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-rabbit_fifo \
@@ -3194,14 +4812,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-rabbit_fifo_int \
@@ -3260,14 +4913,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-rabbit_fifo_prop \
@@ -3326,14 +5014,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-rabbitmq_queues_cli_integration \
@@ -3392,14 +5115,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-rabbitmqctl_integration \
@@ -3458,14 +5216,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-rabbitmqctl_shutdown \
@@ -3524,14 +5317,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-signal_handling \
@@ -3590,14 +5418,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-simple_ha \
@@ -3656,14 +5519,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-single_active_consumer \
@@ -3722,14 +5620,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-sup_delayed_restart \
@@ -3788,14 +5721,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-sync_detection \
@@ -3854,14 +5822,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-term_to_binary_compat_prop \
@@ -3920,14 +5923,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-topic_permission \
@@ -3986,14 +6024,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_access_control \
@@ -4052,14 +6125,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_access_control_authn_authz_context_propagation \
@@ -4118,14 +6226,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_access_control_credential_validation \
@@ -4184,14 +6327,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_amqp091_content_framing \
@@ -4250,14 +6428,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_amqp091_server_properties \
@@ -4316,14 +6529,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_app_management \
@@ -4382,14 +6630,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_cluster_formation_locking_mocks \
@@ -4448,14 +6731,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_collections \
@@ -4514,14 +6832,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_config_value_encryption \
@@ -4580,14 +6933,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_connection_tracking \
@@ -4646,14 +7034,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_credit_flow \
@@ -4712,14 +7135,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_disk_monitor \
@@ -4778,14 +7236,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_disk_monitor_mocks \
@@ -4844,14 +7337,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_file_handle_cache \
@@ -4910,14 +7438,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_gen_server2 \
@@ -4976,14 +7539,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_gm \
@@ -5042,14 +7640,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_log_config \
@@ -5108,14 +7741,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_log_management \
@@ -5174,14 +7842,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_operator_policy \
@@ -5240,14 +7943,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_pg_local \
@@ -5306,14 +8044,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_plugin_directories \
@@ -5372,14 +8145,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_plugin_versioning \
@@ -5438,14 +8246,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_priority_queue \
@@ -5504,14 +8347,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_queue_consumers \
@@ -5570,14 +8448,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_stats_and_metrics \
@@ -5636,14 +8549,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_supervisor2 \
@@ -5702,14 +8650,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_vm_memory_monitor \
@@ -5768,14 +8751,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-upgrade_preparation \
@@ -5834,14 +8852,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-21.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-21.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'oldest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'oldest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-vhost \
diff --git a/.github/workflows/test-erlang-otp-22.3.yaml b/.github/workflows/test-erlang-otp-22.3.yaml
index 342cfd7f1b..1aab4cc02f 100644
--- a/.github/workflows/test-erlang-otp-22.3.yaml
+++ b/.github/workflows/test-erlang-otp-22.3.yaml
@@ -58,23 +58,32 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
       - name: PREPARE SECONDARY UMBRELLA COPIES
         if: success() && 'latest' == 'oldest'
         run: |
+          # ----------------------------------------------------------
+          # CAUTION:
+          # The same script must be copied to `03-CT_SUITE.yaml`. It is used to
+          # recreate the umbrellas if the cache restore fails.
+          # ----------------------------------------------------------
           set -x
-          if ! test -f umbrellas/.ready; then
-            git config --global advice.detachedHead false
-            # We recreate the directory in case something incomplete was
-            # cached.
-            rm -rf umbrellas
-            mkdir -p umbrellas
-            git clone \
-              https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
-              umbrellas/master
-            make -C umbrellas/master co # To get RabbitMQ components.
-            for version in v3.7.x v3.8.3; do
-              umbrella="umbrellas/$version"
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
               # We copy the master Umbrella and checkout the appropriate tag.
               cp -a umbrellas/master "$umbrella"
               git -C "$umbrella" checkout "master"
@@ -87,10 +96,9 @@ jobs:
               make -C "$umbrella" up
               make -C "$umbrella/deps/rabbit" test-dist
               rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
-            done
-            rm -fr umbrellas/master
-            touch umbrellas/.ready
-          fi
+            fi
+          done
+          rm -fr umbrellas/master
   # vim:sw=2:et:
   eunit:
     needs: [checks]
@@ -158,14 +166,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-amqqueue_backward_compatibility \
@@ -224,14 +267,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-backing_queue \
@@ -290,14 +368,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-channel_interceptor \
@@ -356,14 +469,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-channel_operation_timeout \
@@ -422,14 +570,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-cluster \
@@ -488,14 +671,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-cluster_rename \
@@ -554,14 +772,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-clustering_management \
@@ -620,14 +873,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-config_schema \
@@ -686,14 +974,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-confirms_rejects \
@@ -752,14 +1075,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-consumer_timeout \
@@ -818,14 +1176,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-crashing_queues \
@@ -884,14 +1277,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-dead_lettering \
@@ -950,14 +1378,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-definition_import \
@@ -1016,14 +1479,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-disconnect_detected_during_alarm \
@@ -1082,14 +1580,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-dynamic_ha \
@@ -1148,14 +1681,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-dynamic_qq \
@@ -1214,14 +1782,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-eager_sync \
@@ -1280,14 +1883,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-feature_flags \
@@ -1346,14 +1984,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-health_check \
@@ -1412,14 +2085,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-lazy_queue \
@@ -1478,14 +2186,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-list_consumers_sanity_check \
@@ -1544,14 +2287,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-list_queues_online_and_offline \
@@ -1610,14 +2388,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-many_node_ha \
@@ -1676,14 +2489,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-message_size_limit \
@@ -1742,14 +2590,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-metrics \
@@ -1808,14 +2691,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-mirrored_supervisor \
@@ -1874,14 +2792,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-msg_store \
@@ -1940,14 +2893,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-peer_discovery_classic_config \
@@ -2006,14 +2994,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-peer_discovery_dns \
@@ -2072,14 +3095,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-per_user_connection_tracking \
@@ -2138,14 +3196,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-per_vhost_connection_limit \
@@ -2204,14 +3297,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-per_vhost_connection_limit_partitions \
@@ -2270,14 +3398,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-per_vhost_msg_store \
@@ -2336,14 +3499,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-per_vhost_queue_limit \
@@ -2402,14 +3600,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-policy \
@@ -2468,14 +3701,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-priority_queue \
@@ -2534,14 +3802,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-priority_queue_recovery \
@@ -2600,14 +3903,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-product_info \
@@ -2666,14 +4004,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-proxy_protocol \
@@ -2732,14 +4105,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-publisher_confirms_parallel \
@@ -2798,14 +4206,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-queue_length_limits \
@@ -2864,14 +4307,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-queue_master_location \
@@ -2930,14 +4408,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-queue_parallel \
@@ -2996,14 +4509,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-quorum_queue \
@@ -3062,14 +4610,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-rabbit_core_metrics_gc \
@@ -3128,14 +4711,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-rabbit_fifo \
@@ -3194,14 +4812,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-rabbit_fifo_int \
@@ -3260,14 +4913,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-rabbit_fifo_prop \
@@ -3326,14 +5014,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-rabbitmq_queues_cli_integration \
@@ -3392,14 +5115,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-rabbitmqctl_integration \
@@ -3458,14 +5216,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-rabbitmqctl_shutdown \
@@ -3524,14 +5317,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-signal_handling \
@@ -3590,14 +5418,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-simple_ha \
@@ -3656,14 +5519,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-single_active_consumer \
@@ -3722,14 +5620,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-sup_delayed_restart \
@@ -3788,14 +5721,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-sync_detection \
@@ -3854,14 +5822,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-term_to_binary_compat_prop \
@@ -3920,14 +5923,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-topic_permission \
@@ -3986,14 +6024,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_access_control \
@@ -4052,14 +6125,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_access_control_authn_authz_context_propagation \
@@ -4118,14 +6226,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_access_control_credential_validation \
@@ -4184,14 +6327,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_amqp091_content_framing \
@@ -4250,14 +6428,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_amqp091_server_properties \
@@ -4316,14 +6529,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_app_management \
@@ -4382,14 +6630,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_cluster_formation_locking_mocks \
@@ -4448,14 +6731,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_collections \
@@ -4514,14 +6832,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_config_value_encryption \
@@ -4580,14 +6933,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_connection_tracking \
@@ -4646,14 +7034,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_credit_flow \
@@ -4712,14 +7135,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_disk_monitor \
@@ -4778,14 +7236,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_disk_monitor_mocks \
@@ -4844,14 +7337,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_file_handle_cache \
@@ -4910,14 +7438,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_gen_server2 \
@@ -4976,14 +7539,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_gm \
@@ -5042,14 +7640,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_log_config \
@@ -5108,14 +7741,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_log_management \
@@ -5174,14 +7842,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_operator_policy \
@@ -5240,14 +7943,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_pg_local \
@@ -5306,14 +8044,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_plugin_directories \
@@ -5372,14 +8145,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_plugin_versioning \
@@ -5438,14 +8246,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_priority_queue \
@@ -5504,14 +8347,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_queue_consumers \
@@ -5570,14 +8448,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_stats_and_metrics \
@@ -5636,14 +8549,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_supervisor2 \
@@ -5702,14 +8650,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-unit_vm_memory_monitor \
@@ -5768,14 +8751,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-upgrade_preparation \
@@ -5834,14 +8852,49 @@ jobs:
         uses: actions/cache@v1
         with:
           path: umbrellas
-          key: secondary-umbrellas-v3.7.x-v3.8.3-erlang-22.3-rev2
+          key: secondary-umbrellas-v3.7.x-v3.8.x-erlang-22.3-rev3
+      - name: VERIFY SECONDARY UMBRELLA COPIES (in case of cache restore failure)
+        if: success() && 'latest' == 'oldest'
+        run: |
+          set -x
+          for version in v3.7.x v3.8.x; do
+            umbrella="umbrellas/$version"
+            if ! test -d "$umbrella"  ||
+               ! make -C "$umbrella/deps/rabbit" test-dist; then
+              rm -rf "$umbrella"
+
+              # Fetch the master Umbrella; the final umbrellas are created from
+              # the master copy.
+              if ! test -d umbrellas/master; then
+                git config --global advice.detachedHead false
+                git clone \
+                  https://github.com/rabbitmq/rabbitmq-public-umbrella.git \
+                  umbrellas/master
+                make -C umbrellas/master co # To get RabbitMQ components.
+              fi
+
+              # We copy the master Umbrella and checkout the appropriate tag.
+              cp -a umbrellas/master "$umbrella"
+              git -C "$umbrella" checkout "master"
+              make -C "$umbrella" up BRANCH="$version"
+              # To remove third-party deps which were checked out when the
+              # projects were on the `master` branch. Thus, possibly not the
+              # version pinning we expect. We update the Umbrella one last time
+              # to fetch the correct third-party deps.
+              make -C "$umbrella" clean-3rd-party-repos
+              make -C "$umbrella" up
+              make -C "$umbrella/deps/rabbit" test-dist
+              rm -fr "$umbrella"/deps/*/{.git,test} "$umbrella"/.git
+            fi
+          done
+          rm -fr umbrellas/master
       - name: RUN TESTS [mixed-versions]
         if: success() && 'latest' == 'oldest'
         run: |
           set -x
           branch_or_tag_name=${GITHUB_REF#refs/*/}
           for umbrella in umbrellas/*; do
-            test -d $umbrella
+            test -d "$umbrella"
             printf '\n\033[1;32mMixing clusters with RabbitMQ %s\033[0m' \
               $(basename "$umbrella")
             make distclean-ct ct-vhost \