JKNS-637: Remove deprecated references

- Remove CentOS references
- Remove OpenShift V3 references
- Use UBI base image for local development Dockerfile

Signed-off-by: Vinu Kochukuttan <vkochuku@redhat.com>
Signed-off-by: Vinu K <kevy.vinu@gmail.com>

Author: k37y

.gitignore

@@ -1,9 +1,12 @@
 2/Dockerfile.localdev.version
+2/Dockerfile.rhel8.version
+2/Dockerfile.rhel9.version
 agent-maven-3.5/Dockerfile.rhel7.version
 agent-maven-3.5/Dockerfile.localdev.version
 slave-base/Dockerfile.localdev.version
 slave-base/Dockerfile.rhel7.version
 slave-base/Dockerfile.rhel8.version
+slave-base/Dockerfile.rhel9.version
 out
 logs
 kubeconfig

2/Dockerfile.localdev

@@ -1,24 +1,23 @@
 ##############################################
 # Stage 1 : Build go-init
 ##############################################
-FROM openshift/origin-release:golang-1.12 AS go-init-builder
+FROM registry.access.redhat.com/ubi9/go-toolset:1.21 AS go-init-builder
 ARG jenkins_version=latest
 WORKDIR  /go/src/github.com/openshift/jenkins
 COPY . .
 WORKDIR  /go/src/github.com/openshift/jenkins/go-init
-RUN go build . && cp go-init /usr/bin
+RUN GO111MODULE=off go build -o /usr/bin/go-init .
 
 ##############################################
 # Stage 2 : Build slave-base with go-init
 ##############################################
-FROM quay.io/openshift/origin-cli:4.16
+FROM registry.access.redhat.com/ubi9:latest
 ARG jenkins_version=latest
-MAINTAINER Akram Ben Aissi <abenaiss@redhat.com>
 COPY --from=go-init-builder /usr/bin/go-init /usr/bin/go-init
 # Jenkins image for OpenShift
 #
 # This image provides a Jenkins server, primarily intended for integration with
-# OpenShift v3.
+# OpenShift v4.
 #
 # Volumes:
 # * /var/jenkins_home
@@ -31,31 +30,29 @@ ENV JENKINS_VERSION=2 \
     HOME=/var/lib/jenkins \
     JENKINS_HOME=/var/lib/jenkins \
     JENKINS_UC=https://updates.jenkins.io \
-    OPENSHIFT_JENKINS_IMAGE_VERSION=4.10 \
+    OPENSHIFT_JENKINS_IMAGE_VERSION=4.17 \
     LANG=en_US.UTF-8 \
     LC_ALL=en_US.UTF-8 \
     INSTALL_JENKINS_VIA_RPMS=false
 
-LABEL k8s.io.description="Jenkins is a continuous integration server" \
-    k8s.io.display-name="Jenkins 2" \
-    openshift.io.expose-services="8080:http" \
-    openshift.io.tags="jenkins,jenkins2,ci" \
+LABEL io.k8s.description="Jenkins is a continuous integration server" \
+    io.k8s.display-name="Jenkins 2" \
+    maintainer="Prashant Dhamdhere <prdhamdh@redhat.com>, Vinu Kochukuttan <vkochuku@redhat.com>" \
+    io.openshift.expose-services="8080:http" \
+    io.openshift.tags="jenkins,jenkins2,ci" \
     io.jenkins.version="${jenkins_version}" \
-    io.openshift.s2i.scripts-url=image:///usr/libexec/s2i
+    io.openshift.s2i.scripts-url="image:///usr/libexec/s2i"
 
 # 8080 for main web interface, 50000 for slave agents
 EXPOSE 8080 50000
 
-RUN rm /etc/yum.repos.d/*
-COPY contrib/openshift/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo
-RUN curl http://mirror.centos.org/centos/RPM-GPG-KEY-CentOS-Official -o /etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS && \
-    INSTALL_PKGS="dejavu-sans-fonts rsync gettext git git-lfs tar zip unzip openssl bzip2 java-21-openjdk java-21-openjdk-devel java-17-openjdk java-17-openjdk-devel jq xmlstarlet" && \
-    DISABLES="" && \
-    yum $DISABLES -y --setopt=tsflags=nodocs --disableplugin=subscription-manager install epel-release && \
-    yum $DISABLES -y --setopt=tsflags=nodocs --disableplugin=subscription-manager install $INSTALL_PKGS && \
-    yum update --excludepkgs redhat-release -y && \
+RUN INSTALL_PKGS="dejavu-sans-fonts wget rsync gettext git git-lfs tar zip unzip openssl bzip2 java-21-openjdk java-21-openjdk-devel java-17-openjdk java-17-openjdk-devel jq glibc-locale-source xmlstarlet glibc-langpack-en" && \
+    yum install -y $INSTALL_PKGS && \
+    yum update -y && \
     rpm -V  $INSTALL_PKGS && \
     yum clean all && \
+    curl -sL https://mirror.openshift.com/pub/openshift-v4/clients/ocp/stable/openshift-client-linux.tar.gz | tar zxf - -C /usr/bin/ oc \
+    localedef -f UTF-8 -i en_US en_US.UTF-8 && \
     alternatives --set java $(alternatives --display java | grep 'family java-21-openjdk' | cut -d ' ' -f 1) && \
     alternatives --set javac $(alternatives --display javac | grep 'family java-21-openjdk' | cut -d ' ' -f 1) && \
     alternatives --family $(alternatives --display java | grep 'family java-21-openjdk' | cut -d ' ' -f 4) --install /usr/bin/jar  jar $(alternatives --display java | grep 'family java-21-openjdk' | cut -d' ' -f1 | sed 's,/[^/]*$,/jar,') 1 && \
@@ -67,7 +64,7 @@ ADD ./contrib/s2i /usr/libexec/s2i
 ADD release.version /tmp/release.version
 
 RUN /usr/local/bin/install-jenkins-core-plugins.sh /opt/openshift/bundle-plugins.txt && \
-    rmdir /var/log/jenkins && \
+    rm -rf /var/log/jenkins && \
     chmod -R 775 /etc/alternatives && \
     chmod -R 775 /var/lib/alternatives && \
     chmod -R 775 /usr/lib/jvm && \
@@ -81,6 +78,7 @@ RUN /usr/local/bin/install-jenkins-core-plugins.sh /opt/openshift/bundle-plugins
     /usr/local/bin/fix-permissions /var/lib/jenkins && \
     /usr/local/bin/fix-permissions /var/log
 
+
 VOLUME ["/var/lib/jenkins"]
 
 USER 1001

2/cccp.yml

@@ -18,7 +18,8 @@ if [[ "${INSTALL_JENKINS_VIA_RPMS}" == false ]]; then
         echo "jenkins.war already exists, skipping upstream RPM installation"
     else
         echo "Installing jenkins.war from upstream RPM"
-        curl https://pkg.jenkins.io/redhat-stable/jenkins.repo -o /etc/yum.repos.art/ci/jenkins.repo
+        mkdir -p /etc/yum.repos.art/ci
+        curl https://pkg.jenkins.io/redhat-stable/jenkins.repo -o - | tee /etc/yum.repos.d/jenkins.repo /etc/yum.repos.art/ci/jenkins.repo
         rpm --import https://pkg.jenkins.io/redhat-stable/jenkins-ci.org.key
         rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io.key
         rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io-2023.key

2/contrib/jenkins/install-jenkins-core-plugins.sh

@@ -5,7 +5,7 @@
 #
 # Usage:
 #
-# FROM openshift/jenkins-2-centos7
+# FROM registry.redhat.io/ocp-tools-4/jenkins-rhel9:v4.17.0
 # COPY plugins.txt /plugins.txt
 # RUN /usr/local/bin/install-plugins.sh /plugins.txt
 #

2/contrib/jenkins/install-plugins.sh

@@ -33,7 +33,7 @@ var _ = BeforeSuite(func() {
 
 	imageName = os.Getenv("IMAGE_NAME")
 	if imageName == "" {
-		imageName = "openshift/jenkins-2-centos7-candidate"
+		imageName = "openshift/jenkins-2-rhel9-candidate"
 	}
 })
 

2/contrib/openshift/CentOS-Base.repo

@@ -12,7 +12,7 @@ A quick recipe of how to do that via layering would be:
 * create a Dockerfile with (adjusting the image ref as you see fit)
 
 ```
-FROM registry.access.redhat.com/ocp-tools-4/jenkins-rhel8:latest
+FROM registry.redhat.io/ocp-tools-4/jenkins-rhel9:v4.17.0
 COPY ./contrib/openshift /opt/openshift
 ```
 
@@ -23,13 +23,13 @@ the existing run script your new image inherits from this repositories Jenkins i
 Usage
 ---------------------------------
 
-For this, we will assume that you are using an `quay.io/openshift/origin-jenkins` for v4.x.
+For this, we will assume that you are using an `registry.redhat.io/ocp-tools-4/jenkins-rhel9` for v4.x.
 
 If you want to set only the mandatory environment variables and store the database
 in the `/tmp/jenkins` directory on the host filesystem, execute the following command:
 
 ```
-$ docker run -d -e JENKINS_PASSWORD=<password> -v /tmp/jenkins:/var/lib/jenkins openshift/jenkins-2-centos7
+$ docker run -d -e JENKINS_PASSWORD=<password> -v /tmp/jenkins:/var/lib/jenkins ocp-tools-4/jenkins-rhel9:v4.17.0
 ```
 
 

2/test/jenkins_test.go

@@ -1,6 +1,6 @@
 # The master images follow the normal numbering scheme in which the
 # major version is used as the directory name and incorporated into
-# the image name (jenkins-2-centos7 in this case).  For the slave
+# the image name (jenkins-2-rhel9 in this case).  For the slave
 # images we are not versioning them (they actually pull their
 # jars from the jenkins master, so they don't have a jenkins version,
 # so the only thing we'd version is the maven/nodejs version).
@@ -13,10 +13,12 @@ VERSIONS="2 slave-base"
 BUNDLE_PLUGINS="$(shell pwd)/2/contrib/openshift/bundle-plugins.txt"
 REF=$(shell mktemp -d)
 JENKINS_WAR="$(shell mktemp -d)/jenkins.war"
-ifeq ($(TARGET),rhel8)
+ifeq ($(TARGET),rhel9)
+	OS := rhel9
+else ifeq ($(TARGET),rhel8)
 	OS := rhel8
- else
- 	OS := centos8
+else
+ 	OS := ubi
 endif
 
 .PHONY: build

ADVANCED_USAGE.md

@@ -3,56 +3,22 @@
 ### Base set of plugins
 
 An initial set of Jenkins plugins are included in the OpenShift Jenkins images.  The general methodology
-is that the CentOS7 image if first updated with any changes to the list of plugins.  After some level
-of verification with that image, the RHEL7 image is updated.
-```
+is that the UBI image if first updated with any changes to the list of plugins.  After some level
+of verification with that image, the RHEL9 image is updated.
 
-#### Plugin installation for CentOS7 V4
+#### Plugin installation for V4
 In v4, that call has been moved to [this script](2/contrib/jenkins/install-jenkins-core-plugins.sh), which is called from
-both `Dockerfile.localdev`, `Dockerfile.rhel7` and `Dockerfile.rhel8`.
+`Dockerfile.localdev`, `Dockerfile.rhel8` and `Dockerfile.rhel9`.
 
 Where both [base-plugins.txt](2/contrib/openshift/base-plugins.txt) and [install-plugins.sh](2/contrib/jenkins/install-plugins.sh)
 are copied into the image prior to that invocation.
 
 The running of `install-plugins.sh` will download the files listed in `base-plugins.txt`, and then open each plugin's manifest
 and download any needed dependencies listed, including upgrading any previously installed dependencies as needed.
 
-#### Plugin installation for CentOS7 V4.10+
-Starting from `release-4.10`, the `base-plugins.txt` file is instead used to generate `bundle-plugins.txt` which is the comprehensive
-list of plugins used by the Jenkins image. To generate this list, developers must run `make plugins-list` prior to commit `base-plugins.txt`.
-A git hook is provided to enforce that `bundle-plugins.txt` is always newer than `base-plugins.txt` on every commit attempt. And `openshift-ci`
-also runs the `make plugins-list` to be sure that the locally generated list of plugins does not change between the developer commit and the
-ci run.
-The `bundle-plugins.txt` becomes then the source of truth for the ran, tested and verified plugins list. This file is intended to be used by
-anyone who wants to build a Jenkins Image with the exact same set of plugins. Hence, this file is used by the Red Hat internal release
-team (ART) and does not alter the existing release process, except that instead of getting the list of plugins from a succesful build, we now get it
-from a predefined, pre-test and historized file written to the code repository.
-
-
-
-To update the version of a plugin or add a new plugin, construct a PR for this repository that updates `base-plugins.txt` appropriately.
-Administrators for this repository will make sure necessary tests are run and merge the PR when things are ready.
-
-When PRs for this repository's `openshift-3*` branches are merged, they kick off associated builds in the [`push_jenkins_images` job on OpenShift's public
-Jenkins CI/CD server](https://ci.openshift.redhat.com/jenkins/view/All/job/push_jenkins_images/).  When those builds complete,
-new versions of the CentOS7 based versions of the images produced by this repository are pushed to Docker Hub.  See the top of the README for the precise list.
-
-For v4.0, the job definitions for this repository in https://github.com/openshif/release result in our Prow based infrastructure to eventually
-mirror the image content on quay.io.
-
-#### Plugin installation for RHEL7 V3 and V4
-
-Only OpenShift developers working for Red Hat can update the list of plugins for the RHEL7 image.  For those developers, visit this
-[internal Jenkins server](https://buildvm.openshift.eng.bos.redhat.com:8443/job/devex/job/devex%252Fjenkins-plugins/) and log in (contact our CD team for permissions to this job).  Click the `Build with parameters` link, update the `PLUGIN_LIST` field, and submit the build.  The format of the data for the `PLUGIN_LIST` field is the same as `base-plugins.txt`.
-
-The complete list of plugins (i.e. including dependencies) needs to be provided though.  The most straight forward approach is to mine the output of the CentOS7 build which passed verification for the complete list.  Just search for `Installed plugins:` and leverage copy/paste to compile what is needed.
-
-Although this document will refrain on detailing the precise details, once the build on the internal Jenkins server is complete,
-the processes will be set in motion to build the `jenkins-2-plugins` RPM that is installed by the [RHEL7 Dockerfile](2/Dockerfile.rhel7) when the next version of the RHEL7 based OpenShift Jenkins image is built.  When new versions of OpenShift are released, associated versions of the RHEL7 based versions of the images produced by this repository are pushed to the Docker registry provided to RHEL7 subscribers.
+#### Plugin installation for V4.11+
 
-Some reference links for the OpenShift Jenkins developers and where things cross over with the CD/CL/Atomic/RHEL teams:
-* http://pkgs.devel.redhat.com/cgit/rpms/?q=jenkins
-* https://brewweb.engineering.redhat.com/brew/search?match=glob&type=package&terms=*jenkins*
+Starting from `release-4.11`, manually update `base-plugins.txt` and `bundle-plugins.txt` to be the same.
 
 ### Adding plugins or updating existing plugins
 
@@ -64,15 +30,14 @@ The specifics for each approach are detailed below.
 
 #### Installing using layering
 
-In order to install additional Jenkins plugins, the OpenShift Jenkins image provides a way similar to how
-the [initial set of plugins are added](#plugin-installation-for-centos7-v3-only) to this image that will allow one
+In order to install additional Jenkins plugins, the OpenShift Jenkins image provides a way that will allow one
 to add or update by layering on top of this image. The derived image will provide the same functionality
 as described in this documentation, in addition it will also include all plugins you list in the `plugins.txt` file.
 
 To create a derived image in this fashion, create the following `Dockerfile`:
 
 ```
-FROM openshift/jenkins-2-centos7
+FROM registry.redhat.io/ocp-tools-4/jenkins-rhel9
 COPY plugins.txt /opt/openshift/configuration/plugins.txt
 RUN /usr/local/bin/install-plugins.sh /opt/openshift/configuration/plugins.txt
 ```
@@ -114,7 +79,7 @@ folder, so you can also include additional files (like `credentials.xml`, etc.).
 To build your customized Jenkins image, you can then execute following command:
 
 ```console
-$ s2i build https://github.com/your/repository openshift/jenkins-2-centos7 your_image_name
+$ s2i build https://github.com/your/repository registry.redhat.io/ocp-tools-4/jenkins-rhel9 your_image_name
 ```
 NOTE:  if instead of adding a plugin you want to replace an existing plugin via dropping the binary plugin in the `./plugins` directory,
 make sure the filename ends in `.jpi`.