Merge pull request #95 from phracek/fix_openshift_tests

Fix openshift tests for redis container

6

@@ -0,0 +1 @@
+.

Dockerfile

@@ -0,0 +1,80 @@
+FROM registry.fedoraproject.org/f34/s2i-core:latest
+
+# Redis image based on Software Collections packages
+#
+# Volumes:
+#  * /var/lib/redis/data - Datastore for Redis
+# Environment:
+#  * $REDIS_PASSWORD - Database password
+
+ENV NAME=redis \
+    RELEASE=1 \
+    VERSION=6
+
+ENV REDIS_VERSION=$VERSION \
+    HOME=/var/lib/redis
+
+ENV SUMMARY="Redis in-memory data structure store, used as database, cache and message broker" \
+    DESCRIPTION="Redis $REDIS_VERSION available as container, is an advanced key-value store. \
+It is often referred to as a data structure server since keys can contain strings, hashes, lists, \
+sets and sorted sets. You can run atomic operations on these types, like appending to a string; \
+incrementing the value in a hash; pushing to a list; computing set intersection, union and difference; \
+or getting the member with highest ranking in a sorted set. In order to achieve its outstanding \
+performance, Redis works with an in-memory dataset. Depending on your use case, you can persist \
+it either by dumping the dataset to disk every once in a while, or by appending each command to a log."
+
+LABEL summary="$SUMMARY" \
+      description="$DESCRIPTION" \
+      io.k8s.description="$SUMMARY" \
+      io.k8s.display-name="Redis 6" \
+      io.openshift.expose-services="6379:redis" \
+      io.openshift.tags="database,redis,redis6" \
+      com.redhat.component="$NAME" \
+      name="$FGC/$NAME" \
+      version="$VERSION" \
+      usage="docker run -d --name redis_database -p 6379:6379 $FGC/$NAME" \
+      maintainer="SoftwareCollections.org <sclorg@redhat.com>"
+
+EXPOSE 6379
+
+# Create user for redis that has known UID
+# We need to do this before installing the RPMs which would create user with random UID
+# The UID is the one used by the default user from the parent layer (1001),
+# and since the user exists already, do not create a new one, but only rename
+# the existing
+# This image must forever use UID 1001 for redis user so our volumes are
+# safe in the future. This should *never* change, the last test is there
+# to make sure of that.
+RUN getent group  redis &> /dev/null || groupadd -r redis &> /dev/null && \
+    usermod -l redis -aG redis -c 'Redis Server' default &> /dev/null && \
+# Install gettext for envsubst command
+    dnf install -y yum-utils gettext policycoreutils && \
+    INSTALL_PKGS="redis" && \
+    dnf install -y --setopt=tsflags=nodocs --nogpgcheck $INSTALL_PKGS && \
+    rpm -V $INSTALL_PKGS && \
+    dnf clean all && \
+    mkdir -p /var/lib/redis/data && chown -R redis.0 /var/lib/redis && \
+    [[ "$(id redis)" == "uid=1001(redis)"* ]]
+
+# Get prefix path and path to scripts rather than hard-code them in scripts
+ENV CONTAINER_SCRIPTS_PATH=/usr/share/container-scripts/redis \
+    REDIS_PREFIX=/usr \
+    REDIS_CONF=/etc/redis/redis.conf
+
+COPY root /
+
+# this is needed due to issues with squash
+# when this directory gets rm'd by the container-setup
+# script.
+RUN /usr/libexec/container-setup
+
+VOLUME ["/var/lib/redis/data"]
+
+# Using a numeric value because of a comment in [1]:
+# If your S2I image does not include a USER declaration with a numeric user,
+# your builds will fail by default.
+# [1] https://docs.openshift.com/container-platform/4.4/openshift_images/create-images.html#images-create-guide-openshift_create-images
+USER 1001
+
+ENTRYPOINT ["container-entrypoint"]
+CMD ["run-redis"]

Dockerfile.fedora

@@ -0,0 +1 @@
+Dockerfile

README.md

@@ -0,0 +1 @@
+root/usr/share/container-scripts/redis/README.md

bot-cfg.yml

@@ -0,0 +1,20 @@
+---
+version: "1"
+
+betka:
+  # is betka enabled for this repository
+  # optional - defaults to true
+  enabled: true
+  notifications:
+    email_addresses: ["pkubat@redhat.com", "phracek@redhat.com", "hhorak@redhat.com"]
+
+  # Specify if master branch in upstream repository is synced
+  master_checker: true
+  # Should pull requests be synced?
+  pr_checker: false
+  # Path to directory with dockerfile withing upstream repository
+  upstream_git_path: "6"
+  # Github comment message to enforce sync of a pull request
+  pr_comment_message: "[test]"
+  # Specify URL to an image used for dist-git source generation. Like
+  image_url: "quay.io/rhscl/cwt-generator"

dead.package

@@ -1 +0,0 @@
-container sources not used for building fedora containers anymore

help.md

@@ -0,0 +1 @@
+README.md

root/usr/bin/container-entrypoint

@@ -0,0 +1,2 @@
+#!/bin/bash
+exec "$@"

root/usr/bin/run-redis

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+export_vars=$(cgroup-limits); export $export_vars
+source ${CONTAINER_SCRIPTS_PATH}/common.sh
+set -eu
+
+[ -f ${CONTAINER_SCRIPTS_PATH}/validate-variables.sh ] && source ${CONTAINER_SCRIPTS_PATH}/validate-variables.sh
+
+# Process the Redis configuration files
+log_info 'Processing Redis configuration files ...'
+if [[ -v REDIS_PASSWORD ]]; then
+  envsubst < ${CONTAINER_SCRIPTS_PATH}/password.conf.template >> "${REDIS_CONF}"
+else
+  log_info 'WARNING: setting REDIS_PASSWORD is recommended'
+fi
+
+# Source post-init source if exists
+if [ -f ${CONTAINER_SCRIPTS_PATH}/post-init.sh ]; then
+  log_info 'Sourcing post-init.sh ...'
+  source ${CONTAINER_SCRIPTS_PATH}/post-init.sh
+fi
+
+# Restart the Redis server with public IP bindings
+unset_env_vars
+log_volume_info "${REDIS_DATADIR}"
+log_info 'Running final exec -- Only Redis logs after this point'
+exec ${REDIS_PREFIX}/bin/redis-server "${REDIS_CONF}" --daemonize no "$@" 2>&1

root/usr/bin/usage

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+cat /usr/share/container-scripts/redis/README.md
+

root/usr/libexec/container-setup

@@ -0,0 +1,31 @@
+#!/bin/bash
+
+source ${CONTAINER_SCRIPTS_PATH}/common.sh
+set -eu
+
+# setup config file
+if [ -n "${ENABLED_COLLECTIONS:-}" ] ; then
+  mv /etc/opt/rh/rh-redis6/redis.conf "${REDIS_CONF}"
+  ln -s "${REDIS_CONF}" /etc/opt/rh/rh-redis6/redis.conf
+fi
+
+# setup directory for data
+chown -R redis:0 "${HOME}" "${REDIS_CONF}"
+restorecon -R "${HOME}" "${REDIS_CONF}"
+
+# create a symlink for SCL datadir, so there is some reasonable content there
+if [ -n "${ENABLED_COLLECTIONS:-}" ] ; then
+  rmdir /var/opt/rh/rh-redis6/lib/redis/
+  ln -s /var/lib/redis /var/opt/rh/rh-redis6/lib/redis
+fi
+
+# Loosen permission bits for group to avoid problems running container with
+# arbitrary UID
+# When only specifying user, group is 0, that's why /var/lib/redis must have
+# owner redis.0; that allows to avoid a+rwx for this dir
+chmod 0770 "${HOME}" "${REDIS_DATADIR}"
+chmod 0660 "${REDIS_CONF}"
+
+# adjust config with changes we do every-time
+clear_config
+envsubst < ${CONTAINER_SCRIPTS_PATH}/base.conf.template >> "${REDIS_CONF}"

root/usr/share/container-scripts/redis/README.md

@@ -0,0 +1,85 @@
+Redis 6 in-memory data structure store container image
+======================================================
+
+This container image includes Redis 6 in-memory data structure store for OpenShift and general usage.
+Users can choose between RHEL, CentOS and Fedora based images.
+The RHEL images are available in the [Red Hat Container Catalog](https://access.redhat.com/containers/),
+the CentOS images are available on [Quay.io](https://quay.io/organization/centos7),
+and the Fedora images are available in [Fedora Registry](https://registry.fedoraproject.org/).
+The resulting image can be run using [podman](https://github.com/containers/libpod).
+
+Note: while the examples in this README are calling `podman`, you can replace any such calls by `docker` with the same arguments
+
+Description
+-----------
+
+Redis 6 available as container, is an advanced key-value store.
+It is often referred to as a data structure server since keys can contain strings, hashes, lists,
+sets and sorted sets. You can run atomic operations on these types, like appending to a string;
+incrementing the value in a hash; pushing to a list; computing set intersection, union and difference;
+or getting the member with highest ranking in a sorted set. In order to achieve its outstanding
+performance, Redis works with an in-memory dataset. Depending on your use case, you can persist
+it either by dumping the dataset to disk every once in a while, or by appending each command to a log.
+
+
+Usage
+-----
+
+For this, we will assume that you are using the `rhel8/redis-6` image.
+If you want to set only the mandatory environment variables and not store
+the database in a host directory, execute the following command:
+
+```
+$ podman run -d --name redis_database -p 6379:6379 rhel8/redis-6
+```
+
+This will create a container named `redis_database`. Port 6379 will be exposed and mapped
+to the host.
+
+If you want your database to be persistent across container executions, also add a
+`-v /host/db/path:/var/lib/redis/data:Z` argument. This will be the Redis data directory.
+
+For protecting Redis data by a password, pass `REDIS_PASSWORD` environment variable
+to the container like this:
+
+```
+$ podman run -d --name redis_database -e REDIS_PASSWORD=strongpassword rhel8/redis-6
+```
+
+**Warning: since Redis is pretty fast an outside user can try up to
+150k passwords per second against a good box. This means that you should
+use a very strong password otherwise it will be very easy to break.**
+
+
+Environment variables and volumes
+----------------------------------
+
+**`REDIS_PASSWORD`**  
+       Password for the server access
+
+
+You can also set the following mount points by passing the `-v /host:/container:Z` flag to podman.
+
+**`/var/lib/redis/data`**  
+       Redis data directory
+
+
+**Notice: When mouting a directory from the host into the container, ensure that the mounted
+directory has the appropriate permissions and that the owner and group of the directory
+matches the user UID or name which is running inside the container.**
+
+
+Troubleshooting
+---------------
+Redis logs into standard output, so the log is available in the container log. The log can be examined by running:
+
+    podman logs <container>
+
+
+See also
+--------
+Dockerfile and other sources for this container image are available on
+https://github.com/sclorg/redis-container.
+In that repository you also can find another versions of Python environment Dockerfiles.
+Dockerfile for CentOS is called `Dockerfile`, Dockerfile for RHEL7 is called `Dockerfile.rhel7`,
+for RHEL8 it's `Dockerfile.rhel8` and the Fedora Dockerfile is called Dockerfile.fedora.

root/usr/share/container-scripts/redis/base.conf.template

@@ -0,0 +1 @@
+dir ${REDIS_DATADIR}

root/usr/share/container-scripts/redis/common.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+source ${CONTAINER_SCRIPTS_PATH}/helpers.sh
+
+# Data directory where Redis database files live. The data subdirectory is here
+# because .bashrc lives in /var/lib/redis/ and we don't want a
+# volume to override it.
+export REDIS_DATADIR=/var/lib/redis/data
+
+# Be paranoid and stricter than we should be.
+redis_password_regex='^[a-zA-Z0-9_~!@#$%^&*()-=<>,.?;:|]+$'
+
+# Make sure env variables don't propagate to redis process.
+function unset_env_vars() {
+  log_info 'Cleaning up environment variable REDIS_PASSWORD ...'
+  unset REDIS_PASSWORD
+}
+
+# Comment out settings that we'll set in container specifically
+function clear_config() {
+  sed -e "s/^bind/#bind/" \
+      -e "s/^logfile/#logfile/" \
+      -e "s/^dir /#dir /" \
+      -e "/^protected-mode/s/yes/no/" \
+      -i "${REDIS_CONF}"
+}

root/usr/share/container-scripts/redis/helpers.sh

@@ -0,0 +1,24 @@
+function log_info {
+  echo "---> `date +%T`     $@"
+}
+
+function log_and_run {
+  log_info "Running $@"
+  "$@"
+}
+
+function log_volume_info {
+  CONTAINER_DEBUG=${CONTAINER_DEBUG:-}
+  if [[ "${CONTAINER_DEBUG,,}" != "true" ]]; then
+    return
+  fi
+
+  log_info "Volume info for $@:"
+  set +e
+  log_and_run mount
+  while [ $# -gt 0 ]; do
+    log_and_run ls -alZ $1
+    shift
+  done
+  set -e
+}

root/usr/share/container-scripts/redis/password.conf.template

@@ -0,0 +1,3 @@
+# password for the server
+requirepass "${REDIS_PASSWORD}"
+

root/usr/share/container-scripts/redis/post-init.sh

@@ -0,0 +1,6 @@
+# This file serves for extending the container image, typically by changing
+# the configuration, loading some data etc.
+
+# Feel free to add content to this file or rewrite it at all.
+# You may also start redis server locally to load some data for example,
+# but do not forget to stop it after it, so it can be restarted after it.

root/usr/share/container-scripts/redis/scl_enable

@@ -0,0 +1,3 @@
+# This will make scl collection binaries work out of box.
+unset BASH_ENV PROMPT_COMMAND ENV
+source scl_source enable ${ENABLED_COLLECTIONS}

root/usr/share/container-scripts/redis/validate-variables.sh

@@ -0,0 +1,15 @@
+function usage() {
+  [ $# == 1 ] && echo "error: $1"
+  echo "You can specify the following environment variables:"
+  echo "  REDIS_PASSWORD (regex: '$redis_password_regex')"
+  exit 1
+}
+
+function validate_variables() {
+  # Check basic sanity of specified variables
+  if [[ -v REDIS_PASSWORD ]]; then
+    [[ "$REDIS_PASSWORD" =~ $redis_password_regex   ]] || usage "Invalid password"
+  fi
+}
+
+validate_variables

test/examples/redis-ephemeral-template.json

@@ -0,0 +1,216 @@
+{
+  "kind": "Template",
+  "apiVersion": "template.openshift.io/v1",
+  "metadata": {
+    "name": "redis-ephemeral",
+    "annotations": {
+      "openshift.io/display-name": "Redis (Ephemeral)",
+      "description": "Redis in-memory data structure store, without persistent storage. For more information about using this template, including OpenShift considerations, see https://github.com/sclorg/redis-container/blob/master/5.\n\nWARNING: Any data stored will be lost upon pod destruction. Only use this template for testing",
+      "iconClass": "icon-redis",
+      "tags": "database,redis",
+      "openshift.io/long-description": "This template provides a standalone Redis server.  The data is not stored on persistent storage, so any restart of the service will result in all data being lost.",
+      "openshift.io/provider-display-name": "Red Hat, Inc.",
+      "openshift.io/documentation-url": "https://github.com/sclorg/redis-container/tree/master/5",
+      "openshift.io/support-url": "https://access.redhat.com"
+    }
+  },
+  "message": "The following service(s) have been created in your project: ${DATABASE_SERVICE_NAME}.\n\n       Password: ${REDIS_PASSWORD}\n Connection URL: redis://${DATABASE_SERVICE_NAME}:6379/\n\nFor more information about using this template, including OpenShift considerations, see https://github.com/sclorg/redis-container/blob/master/5.",
+  "labels": {
+    "template": "redis-ephemeral-template"
+  },
+  "objects": [
+    {
+      "kind": "Secret",
+      "apiVersion": "v1",
+      "metadata": {
+        "name": "${DATABASE_SERVICE_NAME}",
+        "annotations": {
+          "template.openshift.io/expose-password": "{.data['database-password']}"
+        }
+      },
+      "stringData" : {
+        "database-password" : "${REDIS_PASSWORD}"
+      }
+    },
+    {
+      "kind": "Service",
+      "apiVersion": "v1",
+      "metadata": {
+        "name": "${DATABASE_SERVICE_NAME}",
+        "annotations": {
+          "template.openshift.io/expose-uri": "redis://{.spec.clusterIP}:{.spec.ports[?(.name==\"redis\")].port}"
+        }
+      },
+      "spec": {
+        "ports": [
+          {
+            "name": "redis",
+            "protocol": "TCP",
+            "port": 6379,
+            "targetPort": 6379,
+            "nodePort": 0
+          }
+        ],
+        "selector": {
+          "name": "${DATABASE_SERVICE_NAME}"
+        },
+        "type": "ClusterIP",
+        "sessionAffinity": "None"
+      },
+      "status": {
+        "loadBalancer": {}
+      }
+    },
+    {
+      "kind": "DeploymentConfig",
+      "apiVersion": "apps.openshift.io/v1",
+      "metadata": {
+        "name": "${DATABASE_SERVICE_NAME}",
+        "annotations": {
+          "template.alpha.openshift.io/wait-for-ready": "true"
+        }
+      },
+      "spec": {
+        "strategy": {
+          "type": "Recreate"
+        },
+        "triggers": [
+          {
+            "type": "ImageChange",
+            "imageChangeParams": {
+              "automatic": true,
+              "containerNames": [
+                "redis"
+              ],
+              "from": {
+                "kind": "ImageStreamTag",
+                "name": "redis:${REDIS_VERSION}",
+                "namespace": "${NAMESPACE}"
+              },
+              "lastTriggeredImage": ""
+            }
+          },
+          {
+            "type": "ConfigChange"
+          }
+        ],
+        "replicas": 1,
+        "selector": {
+          "name": "${DATABASE_SERVICE_NAME}"
+        },
+        "template": {
+          "metadata": {
+            "labels": {
+              "name": "${DATABASE_SERVICE_NAME}"
+            }
+          },
+          "spec": {
+            "containers": [
+              {
+                "name": "redis",
+                "image": " ",
+                "ports": [
+                  {
+                    "containerPort": 6379,
+                    "protocol": "TCP"
+                  }
+                ],
+                "readinessProbe": {
+                  "timeoutSeconds": 1,
+                  "initialDelaySeconds": 5,
+                  "exec": {
+                    "command": [ "/bin/sh", "-i", "-c", "test \"$(redis-cli -h 127.0.0.1 -a $REDIS_PASSWORD ping)\" == \"PONG\""]
+                  }
+                },
+                "livenessProbe": {
+                  "timeoutSeconds": 1,
+                  "initialDelaySeconds": 30,
+                  "tcpSocket": {
+                    "port": 6379
+                  }
+                },
+                "env": [
+                  {
+                    "name": "REDIS_PASSWORD",
+                    "valueFrom": {
+                      "secretKeyRef" : {
+                        "name" : "${DATABASE_SERVICE_NAME}",
+                        "key" : "database-password"
+                      }
+                    }
+                  }
+                ],
+                "resources": {
+                  "limits": {
+                    "memory": "${MEMORY_LIMIT}"
+                  }
+                },
+                "volumeMounts": [
+                  {
+                    "name": "${DATABASE_SERVICE_NAME}-data",
+                    "mountPath": "/var/lib/redis/data"
+                  }
+                ],
+                "terminationMessagePath": "/dev/termination-log",
+                "imagePullPolicy": "IfNotPresent",
+                "capabilities": {},
+                "securityContext": {
+                  "capabilities": {},
+                  "privileged": false
+                }
+              }
+            ],
+            "volumes": [
+              {
+                "name": "${DATABASE_SERVICE_NAME}-data",
+                "emptyDir": {
+                  "medium": ""
+                }
+              }
+            ],
+            "restartPolicy": "Always",
+            "dnsPolicy": "ClusterFirst"
+          }
+        }
+      },
+      "status": {}
+    }
+  ],
+  "parameters": [
+    {
+      "name": "MEMORY_LIMIT",
+      "displayName": "Memory Limit",
+      "description": "Maximum amount of memory the container can use.",
+      "value": "512Mi",
+      "required": true
+    },
+    {
+      "name": "NAMESPACE",
+      "displayName": "Namespace",
+      "description": "The OpenShift Namespace where the ImageStream resides.",
+      "value": "openshift"
+    },
+    {
+      "name": "DATABASE_SERVICE_NAME",
+      "displayName": "Database Service Name",
+      "description": "The name of the OpenShift Service exposed for the database.",
+      "value": "redis",
+      "required": true
+    },
+    {
+      "name": "REDIS_PASSWORD",
+      "displayName": "Redis Connection Password",
+      "description": "Password for the Redis connection user.",
+      "generate": "expression",
+      "from": "[a-zA-Z0-9]{16}",
+      "required": true
+    },
+    {
+      "name": "REDIS_VERSION",
+      "displayName": "Version of Redis Image",
+      "description": "Version of Redis image to be used (5-el7, 5-el8, 6-el7, 6-el8, or latest).",
+      "value": "6-el8",
+      "required": true
+    }
+  ]
+}

test/examples/redis-persistent-template.json

@@ -0,0 +1,240 @@
+{
+  "kind": "Template",
+  "apiVersion": "template.openshift.io/v1",
+  "metadata": {
+    "name": "redis-persistent",
+    "annotations": {
+      "openshift.io/display-name": "Redis",
+      "description": "Redis in-memory data structure store, with persistent storage. For more information about using this template, including OpenShift considerations, see https://github.com/sclorg/redis-container/blob/master/5.\n\nNOTE: You must have persistent volumes available in your cluster to use this template.",
+      "iconClass": "icon-redis",
+      "tags": "database,redis",
+      "openshift.io/long-description": "This template provides a standalone Redis server.  The data is stored on persistent storage.",
+      "openshift.io/provider-display-name": "Red Hat, Inc.",
+      "openshift.io/documentation-url": "https://github.com/sclorg/redis-container/tree/master/5",
+      "openshift.io/support-url": "https://access.redhat.com"
+    }
+  },
+  "message": "The following service(s) have been created in your project: ${DATABASE_SERVICE_NAME}.\n\n       Password: ${REDIS_PASSWORD}\n Connection URL: redis://${DATABASE_SERVICE_NAME}:6379/\n\nFor more information about using this template, including OpenShift considerations, see https://github.com/sclorg/redis-container/blob/master/5.",
+  "labels": {
+    "template": "redis-persistent-template"
+  },
+  "objects": [
+    {
+      "kind": "Secret",
+      "apiVersion": "v1",
+      "metadata": {
+        "name": "${DATABASE_SERVICE_NAME}",
+        "annotations": {
+          "template.openshift.io/expose-password": "{.data['database-password']}"
+        }
+      },
+      "stringData" : {
+        "database-password" : "${REDIS_PASSWORD}"
+      }
+    },
+    {
+      "kind": "Service",
+      "apiVersion": "v1",
+      "metadata": {
+        "name": "${DATABASE_SERVICE_NAME}",
+        "annotations": {
+          "template.openshift.io/expose-uri": "redis://{.spec.clusterIP}:{.spec.ports[?(.name==\"redis\")].port}"
+        }
+      },
+      "spec": {
+        "ports": [
+          {
+            "name": "redis",
+            "protocol": "TCP",
+            "port": 6379,
+            "targetPort": 6379,
+            "nodePort": 0
+          }
+        ],
+        "selector": {
+          "name": "${DATABASE_SERVICE_NAME}"
+        },
+        "type": "ClusterIP",
+        "sessionAffinity": "None"
+      },
+      "status": {
+        "loadBalancer": {}
+      }
+    },
+    {
+      "kind": "PersistentVolumeClaim",
+      "apiVersion": "v1",
+      "metadata": {
+        "name": "${DATABASE_SERVICE_NAME}"
+      },
+      "spec": {
+        "accessModes": [
+          "ReadWriteOnce"
+        ],
+        "resources": {
+          "requests": {
+            "storage": "${VOLUME_CAPACITY}"
+          }
+        }
+      }
+    },
+    {
+      "kind": "DeploymentConfig",
+      "apiVersion": "apps.openshift.io/v1",
+      "metadata": {
+        "name": "${DATABASE_SERVICE_NAME}",
+        "annotations": {
+          "template.alpha.openshift.io/wait-for-ready": "true"
+        }
+      },
+      "spec": {
+        "strategy": {
+          "type": "Recreate"
+        },
+        "triggers": [
+          {
+            "type": "ImageChange",
+            "imageChangeParams": {
+              "automatic": true,
+              "containerNames": [
+                "redis"
+              ],
+              "from": {
+                "kind": "ImageStreamTag",
+                "name": "redis:${REDIS_VERSION}",
+                "namespace": "${NAMESPACE}"
+              },
+              "lastTriggeredImage": ""
+            }
+          },
+          {
+            "type": "ConfigChange"
+          }
+        ],
+        "replicas": 1,
+        "selector": {
+          "name": "${DATABASE_SERVICE_NAME}"
+        },
+        "template": {
+          "metadata": {
+            "labels": {
+              "name": "${DATABASE_SERVICE_NAME}"
+            }
+          },
+          "spec": {
+            "containers": [
+              {
+                "name": "redis",
+                "image": " ",
+                "ports": [
+                  {
+                    "containerPort": 6379,
+                    "protocol": "TCP"
+                  }
+                ],
+                "readinessProbe": {
+                  "timeoutSeconds": 1,
+                  "initialDelaySeconds": 5,
+                  "exec": {
+                    "command": [ "/bin/sh", "-i", "-c", "test \"$(redis-cli -h 127.0.0.1 -a $REDIS_PASSWORD ping)\" == \"PONG\""]
+                  }
+                },
+                "livenessProbe": {
+                  "timeoutSeconds": 1,
+                  "initialDelaySeconds": 30,
+                  "tcpSocket": {
+                    "port": 6379
+                  }
+                },
+                "env": [
+                  {
+                    "name": "REDIS_PASSWORD",
+                    "valueFrom": {
+                      "secretKeyRef" : {
+                        "name" : "${DATABASE_SERVICE_NAME}",
+                        "key" : "database-password"
+                      }
+                    }
+                  }
+                ],
+                "resources": {
+                  "limits": {
+                    "memory": "${MEMORY_LIMIT}"
+                  }
+                },
+                "volumeMounts": [
+                  {
+                    "name": "${DATABASE_SERVICE_NAME}-data",
+                    "mountPath": "/var/lib/redis/data"
+                  }
+                ],
+                "terminationMessagePath": "/dev/termination-log",
+                "imagePullPolicy": "IfNotPresent",
+                "capabilities": {},
+                "securityContext": {
+                  "capabilities": {},
+                  "privileged": false
+                }
+              }
+            ],
+            "volumes": [
+              {
+                "name": "${DATABASE_SERVICE_NAME}-data",
+                "persistentVolumeClaim": {
+                  "claimName": "${DATABASE_SERVICE_NAME}"
+                }
+              }
+            ],
+            "restartPolicy": "Always",
+            "dnsPolicy": "ClusterFirst"
+          }
+        }
+      },
+      "status": {}
+    }
+  ],
+  "parameters": [
+    {
+      "name": "MEMORY_LIMIT",
+      "displayName": "Memory Limit",
+      "description": "Maximum amount of memory the container can use.",
+      "value": "512Mi",
+      "required": true
+    },
+    {
+      "name": "NAMESPACE",
+      "displayName": "Namespace",
+      "description": "The OpenShift Namespace where the ImageStream resides.",
+      "value": "openshift"
+    },
+    {
+      "name": "DATABASE_SERVICE_NAME",
+      "displayName": "Database Service Name",
+      "description": "The name of the OpenShift Service exposed for the database.",
+      "value": "redis",
+      "required": true
+    },
+    {
+      "name": "REDIS_PASSWORD",
+      "displayName": "Redis Connection Password",
+      "description": "Password for the Redis connection user.",
+      "generate": "expression",
+      "from": "[a-zA-Z0-9]{16}",
+      "required": true
+    },
+    {
+      "name": "VOLUME_CAPACITY",
+      "displayName": "Volume Capacity",
+      "description": "Volume space available for data, e.g. 512Mi, 2Gi.",
+      "value": "1Gi",
+      "required": true
+    },
+    {
+      "name": "REDIS_VERSION",
+      "displayName": "Version of Redis Image",
+      "description": "Version of Redis image to be used (5-el7, 5-el8, 6-el7, 6-el8, or latest).",
+      "value": "6-el8",
+      "required": true
+    }
+  ]
+}

test/imagestreams/redis-centos.json

@@ -0,0 +1,85 @@
+{
+  "apiVersion": "image.openshift.io/v1",
+  "kind": "ImageStream",
+  "metadata": {
+    "annotations": {
+      "openshift.io/display-name": "Redis"
+    },
+    "name": "redis"
+  },
+  "spec": {
+    "tags": [
+      {
+        "annotations": {
+          "description": "Provides a Redis database on CentOS. For more information about using this database image, including OpenShift considerations, see https://github.com/sclorg/redis-container/tree/master/5/README.md.\n\nWARNING: By selecting this tag, your application will automatically update to use the latest version of Redis available on OpenShift, including major version updates.",
+          "iconClass": "icon-redis",
+          "openshift.io/display-name": "Redis (Latest)",
+          "openshift.io/provider-display-name": "Red Hat, Inc.",
+          "tags": "redis"
+        },
+        "from": {
+          "kind": "ImageStreamTag",
+          "name": "5-el8"
+        },
+        "referencePolicy": {
+          "type": "Local"
+        },
+        "name": "latest"
+      },
+      {
+        "annotations": {
+          "description": "Provides a Redis 5 database on CentOS 8. For more information about using this database image, including OpenShift considerations, see https://github.com/sclorg/redis-container/tree/master/5/README.md.",
+          "iconClass": "icon-redis",
+          "openshift.io/display-name": "Redis 5 (CentOS 8)",
+          "openshift.io/provider-display-name": "Red Hat, Inc.",
+          "tags": "redis",
+          "version": "5"
+        },
+        "from": {
+          "kind": "DockerImage",
+          "name": "docker.io/centos/redis-5-centos8:latest"
+        },
+        "referencePolicy": {
+          "type": "Local"
+        },
+        "name": "5-el8"
+      },
+      {
+        "annotations": {
+          "description": "Provides a Redis 5 database on CentOS 7. For more information about using this database image, including OpenShift considerations, see https://github.com/sclorg/redis-container/tree/master/5/README.md.",
+          "iconClass": "icon-redis",
+          "openshift.io/display-name": "Redis 5 (CentOS 7)",
+          "openshift.io/provider-display-name": "Red Hat, Inc.",
+          "tags": "redis",
+          "version": "5"
+        },
+        "from": {
+          "kind": "DockerImage",
+          "name": "quay.io/centos7/redis-5-centos7:latest"
+        },
+        "referencePolicy": {
+          "type": "Local"
+        },
+        "name": "5-el7"
+      },
+      {
+        "annotations": {
+          "description": "Provides a Redis 5 database on CentOS 7. For more information about using this database image, including OpenShift considerations, see https://github.com/sclorg/redis-container/tree/master/5/README.md.",
+          "iconClass": "icon-redis",
+          "openshift.io/display-name": "Redis 5",
+          "openshift.io/provider-display-name": "Red Hat, Inc.",
+          "tags": "redis,hidden",
+          "version": "5"
+        },
+        "from": {
+          "kind": "DockerImage",
+          "name": "quay.io/centos7/redis-5-centos7:latest"
+        },
+        "referencePolicy": {
+          "type": "Local"
+        },
+        "name": "5"
+      }
+    ]
+  }
+}

test/imagestreams/redis-rhel-aarch64.json

@@ -0,0 +1,67 @@
+{
+  "apiVersion": "image.openshift.io/v1",
+  "kind": "ImageStream",
+  "metadata": {
+    "annotations": {
+      "openshift.io/display-name": "Redis"
+    },
+    "name": "redis"
+  },
+  "spec": {
+    "tags": [
+      {
+        "annotations": {
+          "description": "Provides a Redis database on RHEL. For more information about using this database image, including OpenShift considerations, see https://github.com/sclorg/redis-container/tree/master/6/README.md.\n\nWARNING: By selecting this tag, your application will automatically update to use the latest version of Redis available on OpenShift, including major version updates.",
+          "iconClass": "icon-redis",
+          "openshift.io/display-name": "Redis (Latest)",
+          "openshift.io/provider-display-name": "Red Hat, Inc.",
+          "tags": "redis"
+        },
+        "from": {
+          "kind": "ImageStreamTag",
+          "name": "6-el8"
+        },
+        "referencePolicy": {
+          "type": "Local"
+        },
+        "name": "latest"
+      },
+      {
+        "annotations": {
+          "description": "Provides a Redis 6 database on RHEL 8. For more information about using this database image, including OpenShift considerations, see https://github.com/sclorg/redis-container/tree/master/6/README.md.",
+          "iconClass": "icon-redis",
+          "openshift.io/display-name": "Redis 6 (RHEL 8)",
+          "openshift.io/provider-display-name": "Red Hat, Inc.",
+          "tags": "redis",
+          "version": "6"
+        },
+        "from": {
+          "kind": "DockerImage",
+          "name": "registry.redhat.io/rhel8/redis-6:latest"
+        },
+        "referencePolicy": {
+          "type": "Local"
+        },
+        "name": "6-el8"
+      },
+      {
+        "annotations": {
+          "description": "Provides a Redis 5 database on RHEL 8. For more information about using this database image, including OpenShift considerations, see https://github.com/sclorg/redis-container/tree/master/5/README.md.",
+          "iconClass": "icon-redis",
+          "openshift.io/display-name": "Redis 5 (RHEL 8)",
+          "openshift.io/provider-display-name": "Red Hat, Inc.",
+          "tags": "redis",
+          "version": "5"
+        },
+        "from": {
+          "kind": "DockerImage",
+          "name": "registry.redhat.io/rhel8/redis-5:latest"
+        },
+        "referencePolicy": {
+          "type": "Local"
+        },
+        "name": "5-el8"
+      }
+    ]
+  }
+}

test/imagestreams/redis-rhel.json

@@ -0,0 +1,121 @@
+{
+  "apiVersion": "image.openshift.io/v1",
+  "kind": "ImageStream",
+  "metadata": {
+    "annotations": {
+      "openshift.io/display-name": "Redis"
+    },
+    "name": "redis"
+  },
+  "spec": {
+    "tags": [
+      {
+        "annotations": {
+          "description": "Provides a Redis database on RHEL. For more information about using this database image, including OpenShift considerations, see https://github.com/sclorg/redis-container/tree/master/6/README.md.\n\nWARNING: By selecting this tag, your application will automatically update to use the latest version of Redis available on OpenShift, including major version updates.",
+          "iconClass": "icon-redis",
+          "openshift.io/display-name": "Redis (Latest)",
+          "openshift.io/provider-display-name": "Red Hat, Inc.",
+          "tags": "redis"
+        },
+        "from": {
+          "kind": "ImageStreamTag",
+          "name": "6-el8"
+        },
+        "referencePolicy": {
+          "type": "Local"
+        },
+        "name": "latest"
+      },
+      {
+        "annotations": {
+          "description": "Provides a Redis 6 database on RHEL 8. For more information about using this database image, including OpenShift considerations, see https://github.com/sclorg/redis-container/tree/master/6/README.md.",
+          "iconClass": "icon-redis",
+          "openshift.io/display-name": "Redis 6 (RHEL 8)",
+          "openshift.io/provider-display-name": "Red Hat, Inc.",
+          "tags": "redis",
+          "version": "6"
+        },
+        "from": {
+          "kind": "DockerImage",
+          "name": "registry.redhat.io/rhel8/redis-6:latest"
+        },
+        "referencePolicy": {
+          "type": "Local"
+        },
+        "name": "6-el8"
+      },
+      {
+        "annotations": {
+          "description": "Provides a Redis 6 database on RHEL 7. For more information about using this database image, including OpenShift considerations, see https://github.com/sclorg/redis-container/tree/master/6/README.md.",
+          "iconClass": "icon-redis",
+          "openshift.io/display-name": "Redis 6 (RHEL 7)",
+          "openshift.io/provider-display-name": "Red Hat, Inc.",
+          "tags": "redis",
+          "version": "6"
+        },
+        "from": {
+          "kind": "DockerImage",
+          "name": "registry.redhat.io/rhscl/redis-6-rhel7:latest"
+        },
+        "referencePolicy": {
+          "type": "Local"
+        },
+        "name": "6-el7"
+      },
+      {
+        "annotations": {
+          "description": "Provides a Redis 5 database on RHEL 8. For more information about using this database image, including OpenShift considerations, see https://github.com/sclorg/redis-container/tree/master/5/README.md.",
+          "iconClass": "icon-redis",
+          "openshift.io/display-name": "Redis 5 (RHEL 8)",
+          "openshift.io/provider-display-name": "Red Hat, Inc.",
+          "tags": "redis",
+          "version": "5"
+        },
+        "from": {
+          "kind": "DockerImage",
+          "name": "registry.redhat.io/rhel8/redis-5:latest"
+        },
+        "referencePolicy": {
+          "type": "Local"
+        },
+        "name": "5-el8"
+      },
+      {
+        "annotations": {
+          "description": "Provides a Redis 5 database on RHEL 7. For more information about using this database image, including OpenShift considerations, see https://github.com/sclorg/redis-container/tree/master/5/README.md.",
+          "iconClass": "icon-redis",
+          "openshift.io/display-name": "Redis 5 (RHEL 7)",
+          "openshift.io/provider-display-name": "Red Hat, Inc.",
+          "tags": "redis",
+          "version": "5"
+        },
+        "from": {
+          "kind": "DockerImage",
+          "name": "registry.redhat.io/rhscl/redis-5-rhel7:latest"
+        },
+        "referencePolicy": {
+          "type": "Local"
+        },
+        "name": "5-el7"
+      },
+      {
+        "annotations": {
+          "description": "Provides a Redis 5 database on RHEL 7. For more information about using this database image, including OpenShift considerations, see https://github.com/sclorg/redis-container/tree/master/5/README.md.",
+          "iconClass": "icon-redis",
+          "openshift.io/display-name": "Redis 5",
+          "openshift.io/provider-display-name": "Red Hat, Inc.",
+          "tags": "redis,hidden",
+          "version": "5"
+        },
+        "from": {
+          "kind": "DockerImage",
+          "name": "registry.redhat.io/rhscl/redis-5-rhel7:latest"
+        },
+        "referencePolicy": {
+          "type": "Local"
+        },
+        "name": "5"
+      }
+    ]
+  }
+}

test/redis-ephemeral-template.json

@@ -0,0 +1,216 @@
+{
+  "kind": "Template",
+  "apiVersion": "template.openshift.io/v1",
+  "metadata": {
+    "name": "redis-ephemeral",
+    "annotations": {
+      "openshift.io/display-name": "Redis (Ephemeral)",
+      "description": "Redis in-memory data structure store, without persistent storage. For more information about using this template, including OpenShift considerations, see https://github.com/sclorg/redis-container/blob/master/5.\n\nWARNING: Any data stored will be lost upon pod destruction. Only use this template for testing",
+      "iconClass": "icon-redis",
+      "tags": "database,redis",
+      "openshift.io/long-description": "This template provides a standalone Redis server.  The data is not stored on persistent storage, so any restart of the service will result in all data being lost.",
+      "openshift.io/provider-display-name": "Red Hat, Inc.",
+      "openshift.io/documentation-url": "https://github.com/sclorg/redis-container/tree/master/5",
+      "openshift.io/support-url": "https://access.redhat.com"
+    }
+  },
+  "message": "The following service(s) have been created in your project: ${DATABASE_SERVICE_NAME}.\n\n       Password: ${REDIS_PASSWORD}\n Connection URL: redis://${DATABASE_SERVICE_NAME}:6379/\n\nFor more information about using this template, including OpenShift considerations, see https://github.com/sclorg/redis-container/blob/master/5.",
+  "labels": {
+    "template": "redis-ephemeral-template"
+  },
+  "objects": [
+    {
+      "kind": "Secret",
+      "apiVersion": "v1",
+      "metadata": {
+        "name": "${DATABASE_SERVICE_NAME}",
+        "annotations": {
+          "template.openshift.io/expose-password": "{.data['database-password']}"
+        }
+      },
+      "stringData" : {
+        "database-password" : "${REDIS_PASSWORD}"
+      }
+    },
+    {
+      "kind": "Service",
+      "apiVersion": "v1",
+      "metadata": {
+        "name": "${DATABASE_SERVICE_NAME}",
+        "annotations": {
+          "template.openshift.io/expose-uri": "redis://{.spec.clusterIP}:{.spec.ports[?(.name==\"redis\")].port}"
+        }
+      },
+      "spec": {
+        "ports": [
+          {
+            "name": "redis",
+            "protocol": "TCP",
+            "port": 6379,
+            "targetPort": 6379,
+            "nodePort": 0
+          }
+        ],
+        "selector": {
+          "name": "${DATABASE_SERVICE_NAME}"
+        },
+        "type": "ClusterIP",
+        "sessionAffinity": "None"
+      },
+      "status": {
+        "loadBalancer": {}
+      }
+    },
+    {
+      "kind": "DeploymentConfig",
+      "apiVersion": "apps.openshift.io/v1",
+      "metadata": {
+        "name": "${DATABASE_SERVICE_NAME}",
+        "annotations": {
+          "template.alpha.openshift.io/wait-for-ready": "true"
+        }
+      },
+      "spec": {
+        "strategy": {
+          "type": "Recreate"
+        },
+        "triggers": [
+          {
+            "type": "ImageChange",
+            "imageChangeParams": {
+              "automatic": true,
+              "containerNames": [
+                "redis"
+              ],
+              "from": {
+                "kind": "ImageStreamTag",
+                "name": "redis:${REDIS_VERSION}",
+                "namespace": "${NAMESPACE}"
+              },
+              "lastTriggeredImage": ""
+            }
+          },
+          {
+            "type": "ConfigChange"
+          }
+        ],
+        "replicas": 1,
+        "selector": {
+          "name": "${DATABASE_SERVICE_NAME}"
+        },
+        "template": {
+          "metadata": {
+            "labels": {
+              "name": "${DATABASE_SERVICE_NAME}"
+            }
+          },
+          "spec": {
+            "containers": [
+              {
+                "name": "redis",
+                "image": " ",
+                "ports": [
+                  {
+                    "containerPort": 6379,
+                    "protocol": "TCP"
+                  }
+                ],
+                "readinessProbe": {
+                  "timeoutSeconds": 1,
+                  "initialDelaySeconds": 5,
+                  "exec": {
+                    "command": [ "/bin/sh", "-i", "-c", "test \"$(redis-cli -h 127.0.0.1 -a $REDIS_PASSWORD ping)\" == \"PONG\""]
+                  }
+                },
+                "livenessProbe": {
+                  "timeoutSeconds": 1,
+                  "initialDelaySeconds": 30,
+                  "tcpSocket": {
+                    "port": 6379
+                  }
+                },
+                "env": [
+                  {
+                    "name": "REDIS_PASSWORD",
+                    "valueFrom": {
+                      "secretKeyRef" : {
+                        "name" : "${DATABASE_SERVICE_NAME}",
+                        "key" : "database-password"
+                      }
+                    }
+                  }
+                ],
+                "resources": {
+                  "limits": {
+                    "memory": "${MEMORY_LIMIT}"
+                  }
+                },
+                "volumeMounts": [
+                  {
+                    "name": "${DATABASE_SERVICE_NAME}-data",
+                    "mountPath": "/var/lib/redis/data"
+                  }
+                ],
+                "terminationMessagePath": "/dev/termination-log",
+                "imagePullPolicy": "IfNotPresent",
+                "capabilities": {},
+                "securityContext": {
+                  "capabilities": {},
+                  "privileged": false
+                }
+              }
+            ],
+            "volumes": [
+              {
+                "name": "${DATABASE_SERVICE_NAME}-data",
+                "emptyDir": {
+                  "medium": ""
+                }
+              }
+            ],
+            "restartPolicy": "Always",
+            "dnsPolicy": "ClusterFirst"
+          }
+        }
+      },
+      "status": {}
+    }
+  ],
+  "parameters": [
+    {
+      "name": "MEMORY_LIMIT",
+      "displayName": "Memory Limit",
+      "description": "Maximum amount of memory the container can use.",
+      "value": "512Mi",
+      "required": true
+    },
+    {
+      "name": "NAMESPACE",
+      "displayName": "Namespace",
+      "description": "The OpenShift Namespace where the ImageStream resides.",
+      "value": "openshift"
+    },
+    {
+      "name": "DATABASE_SERVICE_NAME",
+      "displayName": "Database Service Name",
+      "description": "The name of the OpenShift Service exposed for the database.",
+      "value": "redis",
+      "required": true
+    },
+    {
+      "name": "REDIS_PASSWORD",
+      "displayName": "Redis Connection Password",
+      "description": "Password for the Redis connection user.",
+      "generate": "expression",
+      "from": "[a-zA-Z0-9]{16}",
+      "required": true
+    },
+    {
+      "name": "REDIS_VERSION",
+      "displayName": "Version of Redis Image",
+      "description": "Version of Redis image to be used (5-el7, 5-el8, 6-el7, 6-el8, or latest).",
+      "value": "6-el8",
+      "required": true
+    }
+  ]
+}

test/run

@@ -0,0 +1,359 @@
+#!/bin/bash
+#
+# Test the Redis image.
+#
+# IMAGE_NAME specifies the name of the candidate image used for testing.
+# The image has to be available before this script is executed.
+#
+
+set -o errexit
+set -o nounset
+shopt -s nullglob
+
+[ "${DEBUG:-0}" -eq 1 ] && set -x
+
+test -n "${IMAGE_NAME-}" || { echo 'make sure $IMAGE_NAME is defined' && false ;}
+test -n "${VERSION-}" || { echo 'make sure $VERSION is defined' && false; }
+test -n "${OS-}" || { echo 'make sure $OS is defined' && false; }
+
+test_short_summary=''
+TESTSUITE_RESULT=0
+
+TEST_LIST="\
+run_container_creation_tests
+run_tests_no_root
+run_tests_no_pass
+run_tests_no_pass_altuid
+run_tests_no_root_altuid
+run_change_password_test
+run_doc_test
+"
+
+CIDFILE_DIR=$(mktemp --suffix=redis_test_cidfiles -d)
+
+function cleanup() {
+  local cidfile
+  for cidfile in $CIDFILE_DIR/* ; do
+    local CONTAINER
+    CONTAINER=$(cat $cidfile)
+
+    echo "Stopping and removing container $CONTAINER..."
+    docker stop $CONTAINER >/dev/null
+    local exit_status
+    exit_status=$(docker inspect -f '{{.State.ExitCode}}' $CONTAINER)
+    if [ "$exit_status" != "0" ]; then
+      echo "Inspecting container $CONTAINER"
+      docker inspect $CONTAINER
+      echo "Dumping logs for $CONTAINER"
+      docker logs $CONTAINER
+    fi
+    docker rm -v $CONTAINER >/dev/null
+    rm $cidfile
+    echo "Done."
+  done
+  rmdir $CIDFILE_DIR
+
+  echo "$test_short_summary"
+
+  if [ $TESTSUITE_RESULT -eq 0 ] ; then
+    echo "Tests for ${IMAGE_NAME} succeeded."
+  else
+    echo "Tests for ${IMAGE_NAME} failed."
+  fi
+  exit $TESTSUITE_RESULT
+}
+trap cleanup EXIT SIGINT
+
+check_result() {
+  local result="$1"
+  if [[ "$result" != "0" ]]; then
+    TESTCASE_RESULT=1
+  fi
+  return $result
+}
+
+function get_cid() {
+  local id="$1" ; shift || return 1
+  echo $(cat "$CIDFILE_DIR/$id")
+}
+
+function get_container_ip() {
+  local id="$1" ; shift
+  docker inspect --format='{{.NetworkSettings.IPAddress}}' $(get_cid "$id")
+}
+
+function connection_works() {
+  local container_ip="$1"; shift
+  local password="$1"; shift
+  if [ "$(redis_cmd "$container_ip" "$password" ping)" == "PONG" ] ; then
+    return 0
+  fi
+  return 1
+}
+
+function redis_cmd() {
+  local container_ip="$1"; shift
+  local password="$1"; shift
+  # if empty password is given, then no password will be specified
+  docker run --rm "$IMAGE_NAME" redis-cli -h "$container_ip" ${password:+-a "$password"} "$@"
+}
+
+function test_connection() {
+  local name=$1 ; shift
+  local password=$1 ; shift
+  local ip
+  ip=$(get_container_ip $name)
+  echo "  Testing Redis connection to $ip (password='${password:-}')..."
+  local max_attempts=10
+  local sleep_time=2
+  local i
+  for i in $(seq $max_attempts); do
+    echo "    Trying to connect..."
+    if connection_works "$ip" "$password" ; then
+      echo "  Success!"
+      echo
+      return 0
+    fi
+    sleep $sleep_time
+  done
+  echo "  Giving up: Failed to connect. Logs:"
+  docker logs $(get_cid $name)
+  return 1
+}
+
+function test_redis() {
+  local container_ip="$1"
+  local password="$2"
+
+  echo "  Testing Redis (password='${password:-}')"
+  redis_cmd "$container_ip" "$password" set a 1 >/dev/null
+  check_result $?
+  redis_cmd "$container_ip" "$password" set b 2 >/dev/null
+  check_result $?
+  test "$(redis_cmd "$container_ip" "$password" get b)" == '2'
+  echo "  Success!"
+  echo
+}
+
+function create_container() {
+  local name=$1 ; shift
+  cidfile="$CIDFILE_DIR/$name"
+  # create container with a cidfile in a directory for cleanup
+  local container_id
+  [ "${DEBUG:-0}" -eq 1 ] && echo "DEBUG: docker run ${DOCKER_ARGS:-} --cidfile $cidfile -d \"$@\" $IMAGE_NAME ${CONTAINER_ARGS:-}" >&2
+  container_id="$(docker run ${DOCKER_ARGS:-} --cidfile $cidfile -d "$@" $IMAGE_NAME ${CONTAINER_ARGS:-})"
+  [ "${DEBUG:-0}" -eq 1 ] && echo "Created container $container_id"
+  [ x"$container_id" == "x" ] && return 1 || return 0
+}
+
+function run_change_password_test() {
+  local tmpdir=$(mktemp -d)
+  mkdir "${tmpdir}/data" && chmod -R a+rwx "${tmpdir}"
+
+  # Create Redis container with persistent volume and set the initial password
+  create_container "testpass1" -e REDIS_PASSWORD=foo \
+    -v ${tmpdir}:/var/lib/redis/data:Z
+  check_result $?
+  test_connection testpass1 foo
+  check_result $?
+  docker stop $(get_cid testpass1) >/dev/null
+
+  # Create second container with changed password
+  create_container "testpass2" -e REDIS_PASSWORD=bar \
+    -v ${tmpdir}:/var/lib/redis/data:Z
+  check_result $?
+  test_connection testpass2 bar
+  check_result $?
+  # The old password should not work anymore
+  container_ip="$(get_container_ip testpass2)"
+  connection_works "$container_ip" foo
+  check_result $?
+}
+
+function assert_login_access() {
+  local container_ip=$1; shift
+  local PASS=$1 ; shift
+  local success=$1 ; shift
+
+  if connection_works "$container_ip" "$PASS" ; then
+    if $success ; then
+      echo "    Connection ($PASS) access granted as expected"
+      return 0
+    fi
+  else
+    if ! $success ; then
+      echo "    Connection ($PASS) access denied as expected"
+      return 0
+    fi
+  fi
+  echo "    Connection ($PASS) login assertion failed"
+  return 1
+}
+
+function assert_local_access() {
+  local id="$1" ; shift
+  docker exec $(get_cid "$id") bash -c 'redis-cli ping'
+}
+
+# Make sure the invocation of docker run fails.
+function assert_container_creation_fails() {
+
+  # Time the docker run command. It should fail. If it doesn't fail,
+  # redis will keep running so we kill it with SIGKILL to make sure
+  # timeout returns a non-zero value.
+  local ret=0
+  timeout -s 9 --preserve-status 60s docker run --rm "$@" $IMAGE_NAME >/dev/null || ret=$?
+
+  # Timeout will exit with a high number.
+  if [ $ret -gt 10 ]; then
+    return 1
+  fi
+}
+
+function try_image_invalid_combinations() {
+  assert_container_creation_fails -e REDIS_PASSWORD="pass with space" "$@"
+  check_result $?
+}
+
+function run_container_creation_tests() {
+  local ret
+  echo "  Testing image entrypoint usage"
+  try_image_invalid_combinations
+  ret=$?
+  if [ $ret -eq 0 ]; then
+    echo "  Success!"
+  else
+    echo "  Failed!"
+  fi
+  echo
+  return $ret
+}
+
+test_scl_usage() {
+  local name="$1"
+  local run_cmd="$2"
+  local expected="$3"
+
+  echo "  Testing the image SCL enable"
+  local out
+  out=$(docker run --rm ${IMAGE_NAME} /bin/bash -c "${run_cmd}")
+  if ! echo "${out}" | grep -q "${expected}"; then
+    echo "ERROR[/bin/bash -c "${run_cmd}"] Expected '${expected}', got '${out}'"
+    return 1
+  fi
+  out=$(docker exec $(get_cid $name) /bin/bash -c "${run_cmd}" 2>&1)
+  if ! echo "${out}" | grep -q "${expected}"; then
+    echo "ERROR[exec /bin/bash -c "${run_cmd}"] Expected '${expected}', got '${out}'"
+    return 1
+  fi
+  out=$(docker exec $(get_cid $name) /bin/sh -ic "${run_cmd}" 2>&1)
+  if ! echo "${out}" | grep -q "${expected}"; then
+    echo "ERROR[exec /bin/sh -ic "${run_cmd}"] Expected '${expected}', got '${out}'"
+    return 1
+  fi
+}
+
+run_doc_test() {
+  local tmpdir=$(mktemp -d)
+  local f
+  echo "  Testing documentation in the container image"
+  # Extract the help.1 file from the container
+  docker run --rm ${IMAGE_NAME} /bin/bash -c "cat /help.1" >${tmpdir}/help.1
+  # Check whether the help.1 file includes some important information
+  for term in 6379 "REDIS\_PASSWORD" volume; do
+    if ! cat ${tmpdir}/help.1 | grep -F -q -e "${term}" ; then
+      echo "ERROR: File /help.1 does not include '${term}'."
+      return 1
+    fi
+  done
+  # Check whether the file uses the correct format
+  if ! file ${tmpdir}/help.1 | grep -q roff ; then
+    echo "ERROR: /help.1 is not in troff or groff format"
+    return 1
+  fi
+  echo "  Success!"
+  echo
+}
+
+function run_tests() {
+  local name=$1 ; shift
+  local ret
+  envs=${PASS:+"-e REDIS_PASSWORD=$PASS"}
+  PASS=${PASS:-}
+  create_container $name $envs
+  ret=$?
+  check_result $ret
+  test_connection "$name" "$PASS"
+  ret=$?
+  check_result $ret
+  # Only check version on rhel/centos builds
+  if [ "$OS" != "fedora" ]; then
+    echo "  Testing scl usage"
+    test_scl_usage $name 'redis-server --version' "$VERSION"
+    check_result $?
+  fi
+  echo "  Testing login accesses"
+  local container_ip
+  container_ip=$(get_container_ip $name)
+  assert_login_access "$container_ip" "$PASS" true
+  ret=$?
+  check_result $ret
+  if [ -n "$PASS" ] ; then
+    assert_login_access "$container_ip" "${PASS}_foo" false
+    check_result $?
+  fi
+  assert_local_access "$name"
+  ret=$?
+  check_result $ret
+  if [ $ret -ne 0 ]; then
+    echo "  Local access FAILED."
+  else
+    echo "  Local access SUCCESS."
+  fi
+  echo
+  test_redis "$container_ip" "$PASS"
+  check_result $?
+}
+
+function run_tests_no_root() {
+  # Normal tests with password
+  PASS=pass run_tests no_root
+}
+
+function run_tests_no_pass() {
+  # Normal tests without password
+  run_tests no_pass
+}
+
+function run_tests_no_pass_altuid() {
+  # Test with arbitrary uid for the container without password
+  DOCKER_ARGS="-u 12345" run_tests no_pass_altuid
+}
+
+function run_tests_no_root_altuid() {
+  # Test with arbitrary uid for the container with password
+  DOCKER_ARGS="-u 12345" PASS=pass run_tests no_root_altuid
+}
+
+function run_all_tests() {
+  for test_case in $TEST_SET; do
+    echo "Running test $test_case ...."
+    TESTCASE_RESULT=0
+    $test_case
+    check_result $?
+    local test_msg
+    if [ $TESTCASE_RESULT -eq 0 ]; then
+      test_msg="[PASSED]"
+    else
+      test_msg="[FAILED]"
+      TESTSUITE_RESULT=1
+    fi
+    printf -v test_short_summary "%s %s for '%s' %s\n" "${test_short_summary}" "${test_msg}" "$test_case"
+    [ -n "${FAIL_QUICKLY:-}" ] && cleanup "${APP_NAME}" && return 1
+  done;
+}
+
+TEST_SET=${TESTS:-$TEST_LIST} run_all_tests
+
+echo "Success!"
+cleanup

test/run-openshift

@@ -0,0 +1 @@
+run-openshift-local-cluster

test/run-openshift-local-cluster

@@ -0,0 +1,119 @@
+#!/bin/bash
+#
+# Test the Redis image in OpenShift.
+#
+# IMAGE_NAME specifies a name of the candidate image used for testing.
+# The image has to be available before this script is executed.
+#
+
+THISDIR=$(dirname ${BASH_SOURCE[0]})
+
+source "$THISDIR"/test-lib-openshift.sh
+source ${THISDIR}/test-lib-redis.sh
+
+set -eo nounset
+
+trap ct_os_cleanup EXIT SIGINT
+
+ct_os_check_compulsory_vars
+
+ct_os_enable_print_logs
+
+function check_redis_os_service_connection() {
+  local util_image_name=$1 ; shift
+  local service_name=$1 ; shift
+  local pass=$1 ; shift
+  local timeout=${1:-60} ; shift || :
+  local pod_ip=$(ct_os_get_service_ip ${service_name})
+
+  : "  Service ${service_name} check ..."
+
+  local cmd="timeout 15 redis-cli -h $pod_ip -a $pass ping"
+  local expected_value="PONG"
+  local output
+  local ret
+  SECONDS=0
+
+  echo -n "Waiting for ${service_name} service becoming ready ..."
+  while true ; do
+    output=$(docker run --rm ${util_image_name} bash -c "${cmd}" || :)
+    echo "${output}" | grep -qe "${expected_value}" && ret=0 || ret=1
+    if [ ${ret} -eq 0 ] ; then
+      echo " PASS"
+      return 0
+    fi
+    echo -n "."
+    [ ${SECONDS} -gt ${timeout} ] && break
+    sleep 3
+  done
+  echo " FAIL"
+  return 1
+}
+
+function test_redis_pure_image() {
+  local image_name=$1
+  local image_name_no_namespace=${image_name##*/}
+  local service_name="${image_name_no_namespace%%:*}-testing"
+
+  ct_os_new_project
+  # Create a specific imagestream tag for the image so that oc cannot use anything else
+  ct_os_upload_image "${image_name}" "$image_name_no_namespace"
+
+  ct_os_deploy_pure_image "$image_name_no_namespace" \
+                          --name "${service_name}" \
+                          --env REDIS_PASSWORD=pass
+
+  ct_os_wait_pod_ready "${service_name}" 60
+  check_redis_os_service_connection "${image_name}" "${service_name}" pass
+
+  ct_os_delete_project
+}
+
+function test_redis_template() {
+  local image_name=${1:-quay.io/centos7/redis-5-centos7}
+  local image_name_no_namespace=${image_name##*/}
+  local service_name="${image_name_no_namespace%%:*}-testing"
+
+  ct_os_new_project
+  ct_os_upload_image "${image_name}" "redis:$VERSION"
+
+  ct_os_deploy_template_image "$THISDIR/redis-ephemeral-template.json" \
+                              NAMESPACE="$(oc project -q)" \
+                              REDIS_VERSION="$VERSION" \
+                              DATABASE_SERVICE_NAME="${service_name}" \
+                              REDIS_PASSWORD=pass
+
+  ct_os_wait_pod_ready "${service_name}" 60
+  check_redis_os_service_connection "${image_name}" "${service_name}" pass
+
+  ct_os_delete_project
+}
+
+ct_os_cluster_up
+test_redis_pure_image "${IMAGE_NAME}"
+test_redis_template "${IMAGE_NAME}"
+
+# test with the just built image and an integrated template
+test_redis_integration "${IMAGE_NAME}"
+
+# test with a released image and an integrated template
+PUBLIC_IMAGE_NAME=${PUBLIC_IMAGE_NAME:-$(ct_get_public_image_name "${OS}" "${BASE_IMAGE_NAME}" "${VERSION}")}
+
+# Try pulling the image first to see if it is accessible
+if ct_check_image_availability "$PUBLIC_IMAGE_NAME"; then
+  test_redis_integration "${PUBLIC_IMAGE_NAME}"
+else
+  echo "Warning: ${PUBLIC_IMAGE_NAME} could not be downloaded via 'docker'"
+  # ignore possible failure of this test for centos images
+  [ "${OS}" == "rhel7" ] && false "ERROR: Failed to pull image"
+fi
+
+# Check the imagestream
+test_redis_imagestream
+
+OS_TESTSUITE_RESULT=0
+
+ct_os_cluster_down
+
+# vim: set tabstop=2:shiftwidth=2:expandtab:
+

test/run-openshift-remote-cluster

@@ -0,0 +1,37 @@
+#!/bin/bash
+#
+# Test the Redis image in OpenShift (remote cluster)
+#
+# IMAGE_NAME specifies a name of the candidate image used for testing.
+# The image has to be available before this script is executed.
+# VERSION specifies the major version of the Redis in format of X.Y
+# OS specifies RHEL version (e.g. OS=rhel7)
+#
+
+THISDIR=$(dirname ${BASH_SOURCE[0]})
+
+source ${THISDIR}/test-lib-redis.sh
+
+set -eo nounset
+
+trap ct_os_cleanup EXIT SIGINT
+
+ct_os_set_ocp4
+
+ct_os_check_compulsory_vars
+
+oc status || false "It looks like oc is not properly logged in."
+
+# For testing on OpenShift 4 we use external registry
+export CT_EXTERNAL_REGISTRY=true
+
+# Check the template
+test_redis_integration "${IMAGE_NAME}"
+
+# Check the imagestream
+test_redis_imagestream
+
+OS_TESTSUITE_RESULT=0
+
+# vim: set tabstop=2:shiftwidth=2:expandtab:
+

test/test-lib-redis.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+#
+# Functions for tests for the Redis image in OpenShift.
+#
+# IMAGE_NAME specifies a name of the candidate image used for testing.
+# The image has to be available before this script is executed.
+#
+
+THISDIR=$(dirname ${BASH_SOURCE[0]})
+
+source ${THISDIR}/test-lib.sh
+source ${THISDIR}/test-lib-openshift.sh
+source ${THISDIR}/test-lib-remote-openshift.sh
+
+function test_redis_integration() {
+  local image_name=$1
+  local service_name=redis
+  ct_os_test_template_app_func "${image_name}" \
+                               "https://raw.githubusercontent.com/openshift/origin/master/examples/db-templates/redis-ephemeral-template.json" \
+                               "${service_name}" \
+                               "ct_os_check_cmd_internal '<SAME_IMAGE>' '${service_name}-testing' 'timeout 15 redis-cli -h <IP> -a testp ping' 'PONG'" \
+                               "-p REDIS_VERSION=${VERSION} \
+                                -p DATABASE_SERVICE_NAME="${service_name}-testing" \
+                                -p REDIS_PASSWORD=testp"
+}
+
+# Check the imagestream
+function test_redis_imagestream() {
+  case ${OS} in
+    rhel7|centos7) ;;
+    *) echo "Imagestream testing not supported for $OS environment." ; return 0 ;;
+  esac
+  local tag="-el7"
+  if [ "${OS}" == "rhel8" ]; then
+    tag="-el8"
+  fi
+  ct_os_test_image_stream_template "${THISDIR}/../imagestreams/redis-${OS%[0-9]*}.json" "${THISDIR}/../examples/redis-ephemeral-template.json" redis "-p REDIS_VERSION=${VERSION}${tag}"
+}
+
+# vim: set tabstop=2:shiftwidth=2:expandtab:

test/test-lib-remote-openshift.sh

@@ -0,0 +1,116 @@
+# shellcheck shell=bash
+# some functions are used from test-lib.sh, that is usually in the same dir
+# shellcheck source=/dev/null
+source "$(dirname "${BASH_SOURCE[0]}")"/test-lib.sh
+
+# Set of functions for testing docker images in OpenShift using 'oc' command
+
+# A variable containing the overall test result; must be changed to 0 in the end
+# of the testing script:
+#   OS_TESTSUITE_RESULT=0
+# And the following trap must be set, in the beginning of the test script:
+#   trap ct_os_cleanup EXIT SIGINT
+
+# ct_os_set_path_oc_4 OC_VERSION
+# --------------------
+# This is a trick that helps using correct version 4 of the `oc`:
+# The input is version of the openshift in format 4.4 etc.
+# If the currently available version of oc is not of this version,
+# it first takes a look into /usr/local/oc-<ver>/bin directory,
+
+# Arguments: oc_version - X.Y part of the version of OSE (e.g. 3.9)
+function ct_os_set_path_oc_4() {
+    echo "Setting OCP4 client"
+    local oc_version=$1
+    local installed_oc_path="/usr/local/oc-v${oc_version}/bin"
+    echo "PATH ${installed_oc_path}"
+    if [ -x "${installed_oc_path}/oc" ] ; then
+        oc_path="${installed_oc_path}"
+        echo "Binary oc found in ${installed_oc_path}" >&2
+    else
+       echo "OCP4 not found"
+       return 1
+    fi
+    export PATH="${oc_path}:${PATH}"
+    oc version
+    if ! oc version | grep -q "Client Version: ${oc_version}." ; then
+        echo "ERROR: something went wrong, oc located at ${oc_path}, but oc of version ${oc_version} not found in PATH ($PATH)" >&1
+        return 1
+    else
+        echo "PATH set correctly, binary oc found in version ${oc_version}: $(command -v oc)"
+    fi
+}
+
+# ct_os_prepare_ocp4
+# ------------------
+# Prepares environment for testing images in OpenShift 4 environment
+#
+#
+function ct_os_set_ocp4() {
+  if [ "${CVP:-0}" -eq "1" ]; then
+    echo "Testing in CVP environment. No need to login to OpenShift cluster. This is already done by CVP pipeline."
+    return
+  fi
+  local login
+  OS_OC_CLIENT_VERSION=${OS_OC_CLIENT_VERSION:-4.4}
+  ct_os_set_path_oc_4 "${OS_OC_CLIENT_VERSION}"
+
+  oc version
+
+  login=$(cat "$KUBEPASSWORD")
+  oc login -u kubeadmin -p "$login"
+  echo "Login to OpenShift ${OS_OC_CLIENT_VERSION} is DONE"
+  # let openshift cluster to sync to avoid some race condition errors
+  sleep 3
+}
+
+function ct_os_upload_image_external_registry() {
+  local input_name="${1}" ; shift
+  local image_name=${input_name##*/}
+  local imagestream=${1:-$image_name:latest}
+  local output_name
+
+  ct_os_login_external_registry
+
+  output_name="${INTERNAL_DOCKER_REGISTRY}/rhscl-ci-testing/$imagestream"
+
+  docker images
+  docker tag "${input_name}" "${output_name}"
+  docker push "${output_name}"
+}
+
+
+function ct_os_login_external_registry() {
+  local docker_token
+  # docker login fails with "404 page not found" error sometimes, just try it more times
+  # shellcheck disable=SC2034
+  echo "loging"
+  [ -z "${INTERNAL_DOCKER_REGISTRY:-}" ] && "INTERNAL_DOCKER_REGISTRY has to be set for working with Internal registry" && return 1
+  # shellcheck disable=SC2034
+  for i in $(seq 12) ; do
+    # shellcheck disable=SC2015
+    docker_token=$(cat "$DOCKER_UPSHIFT_TOKEN")
+    # shellcheck disable=SC2015
+    docker login -u rhscl-ci-testing -p "$docker_token" "${INTERNAL_DOCKER_REGISTRY}" && return 0 || :
+    sleep 5
+  done
+  return 1
+}
+
+function ct_os_import_image_ocp4() {
+  local image_name="${1}"; shift
+  local imagestream=${1:-$image_name:latest}
+  local namespace
+
+  namespace=${CT_NAMESPACE:-"$(oc project -q)"}
+  deploy_image_name="${INTERNAL_DOCKER_REGISTRY}/rhscl-ci-testing/${imagestream}"
+  echo "Uploading image ${image_name} as ${deploy_image_name} , ${imagestream} into external registry."
+  ct_os_upload_image_external_registry "${image_name}" "${imagestream}"
+  if [ "${CT_TAG_IMAGE:-false}" == 'true' ]; then
+    echo "Tag ${deploy_image_name} to ${namespace}/${imagestream}"
+    oc tag --source=docker "${deploy_image_name}" "${namespace}/${imagestream}" --insecure=true --reference-policy=local
+  else
+    echo "Import image into OpenShift 4 environment ${namespace}/${imagestream} from ${deploy_image_name}"
+    oc import-image "${namespace}/${imagestream}" --from="${deploy_image_name}" --confirm --reference-policy=local
+  fi
+}