We had an issue once to give all other
                              ee4j members read access for other CIs for
                              the ee4j projects, but seemingly that is
                              some manual thing then that must be
                              periodically updated.
                            #!/bin/bash -ex
                              if [ ${DROP_FIRST} = 'true' ] || [
                              ${LIST_FIRST} = 'true' ]; then
                                 exit 0
                              fi
                              
                              
                              MVN_HOME="/opt/tools/apache-maven/latest"
JAVA_HOME="/opt/tools/java/openjdk/jdk-11/latest"
                              
PATH="${MVN_HOME}/bin:${JAVA_HOME}/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
                              
                              # Maven plugins
VERSIONS_PLUGIN='org.codehaus.mojo:versions-maven-plugin:2.5'
HELP_PLUGIN='org.apache.maven.plugins:maven-help-plugin:2.1.1'
                              MVN_EXTRA='--batch-mode
-Dorg.slf4j.simpleLogger.log.org.apache.maven.cli.transfer.Slf4jMavenTransferListener=warn'
                              MAVEN_SKIP_RC=1
                              
                              # Directory with project top level pom.xml
                              BUILD_DIR="${WORKSPACE}/api"
                              
                              cd ${BUILD_DIR}
                              
                              
                              # Check whether top level pom.xml contains
                              SNAPSHOT version
                              if ! grep '<version>' pom.xml | grep
                              'RC' ; then
                                echo '-[ Not an RC version
                              ]-------------------------------------------'
                                  
                                # Check whether top level pom.xml
                              contains SNAPSHOT version
                                if ! grep '<version>' pom.xml |
                              grep 'SNAPSHOT' ; then
                                  echo '-[ Missing SNAPSHOT version in
                              POM!
                              ]-------------------------------------------'
                                  exit 1
                                fi
                                
                                # Compute release versions
                                SNAPSHOT_VERSION=`mvn ${MVN_EXTRA} -B
                              ${HELP_PLUGIN}:evaluate
                              -Dexpression=project.version 2>
                              /dev/null | grep -E
                              '^[0-9]+(\.[0-9]+)+-SNAPSHOT$'`
                                
                                if [ -z "${RELEASE_VERSION}" ]; then
                                  if [ -z ${SNAPSHOT_VERSION} ]; then
                                    echo '-[ Missing required snapshot
                              version number!
                              ]----------------------------------'
                                  fi
                                  RELEASE_VERSION=`echo
                              ${SNAPSHOT_VERSION} | sed -e
                              's/-SNAPSHOT//'`
                                fi
                                
                                # Bash specific code
                                if [ -z "${NEXT_VERSION}" ]; then
                                  NEXT_VERSION=`echo ${RELEASE_VERSION}
                              | sed -e
                              's/\([0-9][0-9]*\.[0-9][0-9]*\).*/\1/'`
                                  set -f
                                 
                              NEXT_COMPONENTS=(${RELEASE_VERSION//\./ })
                                  LAST_INDEX=$((${#NEXT_COMPONENTS[@]} -
                              1))
                                 
                              NEXT_COMPONENTS[${LAST_INDEX}]=$((${NEXT_COMPONENTS[${LAST_INDEX}]}
                              + 1))
                                  NEXT_VERSION=`echo
                              ${NEXT_COMPONENTS[@]} | tr ' '
                              '.'`'-SNAPSHOT'
                                fi
                              else
                                SNAPSHOT_VERSION=`mvn ${MVN_EXTRA} -B
                              ${HELP_PLUGIN}:evaluate
                              -Dexpression=project.version 2>
                              /dev/null | grep -E
                              '^[0-9]+(\.[0-9]+)+-RC[0-9]+$'`
                                RELEASE_VERSION=${SNAPSHOT_VERSION}
                                NEXT_VERSION=${SNAPSHOT_VERSION}
                              fi
                              
                              RELEASE_TAG="${RELEASE_VERSION}-RELEASE"
                              
                              echo "Current version:
                              ${SNAPSHOT_VERSION}"
                              echo "Release version: ${RELEASE_VERSION}"
                              echo "Next version:    ${NEXT_VERSION}"
                              echo "Release tag:     ${RELEASE_TAG}"
                              
                              if [ -z "${SNAPSHOT_VERSION}" -o -z
                              "${RELEASE_VERSION}" -o -z
                              "${NEXT_VERSION}" ]; then
                                echo '-[ Missing required version
                              numbers!
                              ]------------------------------------------'
                                exit 1
                              fi
                              
                              if [ ${DRY_RUN} = 'true' ]; then
                                echo '-[ Dry run turned on
                              ]----------------------------------------------------------'
                                MVN_DEPLOY_ARGS=''
                                echo '-[ Skipping GitHub branch and tag
                              checks
                              ]--------------------------------------'
                              else
                                # MVN_DEPLOY_ARGS='deploy:deploy'
                                MVN_DEPLOY_ARGS='nexus-staging:deploy'
                                GIT_ORIGIN=`git remote`
                                
                                echo '-[ Prepare branch
                              ]-------------------------------------------------------------'
                                if [[ -n `git branch -r | grep
                              "${GIT_ORIGIN}/${RELEASE_VERSION}"` ]];
                              then
                                  if [ "${OVERWRITE}" = 'true' ]; then
                                    echo
                              "${GIT_ORIGIN}/${RELEASE_VERSION} branch
                              already exists, deleting"
                                    git push --delete origin
                              "${RELEASE_VERSION}" && true
                                  else
                                    echo "Error:
                              ${GIT_ORIGIN}/${RELEASE_VERSION} branch
                              already exists"
                                    exit 1
                                  fi
                                fi
                                
                                echo '-[ Release tag cleanup
                              ]--------------------------------------------------------'
                                if [[ -n `git ls-remote --tags
                              ${GIT_ORIGIN} | grep "${RELEASE_TAG}"` ]];
                              then
                                  if [ "${OVERWRITE}" = 'true' ]; then
                                    echo "${RELEASE_TAG} tag already
                              exists, deleting"
                                    git push --delete origin
                              "${RELEASE_TAG}" && true
                                  else
                                    echo "Error: ${RELEASE_TAG} tag
                              already exists"
                                    exit 1
                                  fi
                                fi
                              fi
                              
                              cd ${WORKSPACE}
                              
                              # Always delete local branch if exists
                              git branch --delete "${RELEASE_VERSION}"
                              && true
                              git checkout -b ${RELEASE_VERSION}
                              
                              # Always delete local tag if exists
                              git tag --delete "${RELEASE_TAG}"
                              && true
                              
                              
                              
                              cd ${BUILD_DIR}
                              
                              # Project identifiers
                              ARTIFACT_ID=$(mvn ${MVN_EXTRA} -B
                              ${HELP_PLUGIN}:evaluate
                              -Dexpression=project.artifactId | grep -Ev
                              '(^\[)')
                              GROUP_ID=$(mvn ${MVN_EXTRA} -B
                              ${HELP_PLUGIN}:evaluate
                              -Dexpression=project.groupId | grep -Ev
                              '(^\[)')
                              
                              
                              
                              if [ ${SNAPSHOT_VERSION} !=
                              ${RELEASE_VERSION} ]; then
                                echo '-[ Set release version
                              ]--------------------------------------------------------'
                                
                                # Set release version
                                mvn -U -C \
                                    -DnewVersion="${RELEASE_VERSION}" \
                                    -DgenerateBackupPoms=false \
                                    clean ${VERSIONS_PLUGIN}:set
                              ${MVN_EXTRA}
                                
                                cd ${WORKSPACE}
                                
                                echo '-[ Commit modified pom.xml files
                              ]----------------------------------------------'
                                POM_FILES=`git status | grep -E
                              'modified:.*pom\.xml' | sed -e
                              's/[[:space:]][[:space:]]*modified:[[:space:]][[:space:]]*//'`
                                git add ${POM_FILES} && \
                                git commit -m "Prepare release
                              ${GROUP_ID}:${ARTIFACT_ID}:${RELEASE_VERSION}"
                              fi
                              
                              
                              
                              echo '-[ Deploy artifacts to staging
                              repository
                              ]-------------------------------------'
                              cd ${BUILD_DIR}
                              mvn -U -C -s
                              /home/jenkins/.m2/settings.xml \
                                  -DskipTests -Ddoclint=none
                              -Poss-release \
                                  clean package \
                                  gpg:sign install:install \
                                  ${MVN_DEPLOY_ARGS} ${MVN_EXTRA}
                                  
                              # Typical output of this step:
                              #  * Remote staging into staging profile
                              ID "6f25e242715ce0"
                              #  * Created staging repository with ID
                              "jakartasecurityauthmessage-1003".
                              #  * Staging repository at 
https://oss.sonatype.org:443/service/local/staging/deployByRepositoryId/jakartasecurityauthmessage-1003
                              #  * Uploading locally staged artifacts to
                              profile jakarta.security.auth.message
                              #  * Upload of locally staged artifacts
                              finished.
                              #  * Closing staging repository with ID
                              "jakartasecurityauthmessage-1003".
                              
                              
                              
                              echo '-[ Tag release
                              ]----------------------------------------------------------------'
                              cd ${WORKSPACE}
                              git tag "${RELEASE_TAG}" -m "Release
                              ${GROUP_ID}:${ARTIFACT_ID}:${RELEASE_VERSION}"
                              
                              
                              cd ${BUILD_DIR}
                              if [ ${SNAPSHOT_VERSION} !=
                              ${NEXT_VERSION} ]; then
                                echo '-[ Set next snapshot version
                              ]--------------------------------------------------'
                                mvn -U -C \
                                    -DnewVersion="${NEXT_VERSION}" \
                                    -DgenerateBackupPoms=false \
                                    clean ${VERSIONS_PLUGIN}:set
                              ${MVN_EXTRA}
                                
                                cd ${WORKSPACE}
                                
                                echo '-[ Commit modified pom.xml files
                              ]----------------------------------------------'
                                POM_FILES=`git status | grep -E
                              'modified:.*pom\.xml' | sed -e
                              's/[[:space:]][[:space:]]*modified:[[:space:]][[:space:]]*//'`
                                git add ${POM_FILES} && \
                                git commit -m "Prepare next development
                              cycle for ${NEXT_VERSION}"
                              fi
                              
                              
                              GIT_STATUS=`git status`
                              
                              echo $GIT_STATUS
                              
                              if [ ${DRY_RUN} = 'true' ]; then
                                echo '-[ Skipping GitHub update
                              ]-----------------------------------------------------'
                              else
                                echo '-[ Push branch and tag to GitHub
                              ]----------------------------------------------'
                                git push origin "${RELEASE_VERSION}"
                                git push origin "${RELEASE_TAG}"
                              fi