container/ruby
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge pull request #348 from phracek/support_github_matrix

Browse source 
Support GitHub matrix
This commit is contained in:
phracek 2021-11-23 13:19:17 +00:00
commit 05c36dd1ce
36 changed files with 3872 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

1
2.7 Symbolic link
View file

@ -0,0 +1 @@
.

51
Dockerfile Normal file
View file

@ -0,0 +1,51 @@
FROM registry.fedoraproject.org/f33/s2i-base:latest
# This image provides a Ruby environment you can use to run your Ruby
# applications.
EXPOSE 8080
ENV NAME=ruby \
RUBY_VERSION=2.7 \
RUBY_SHORT_VER=27 \
VERSION=0
ENV SUMMARY="Platform for building and running Ruby $RUBY_VERSION applications" \
DESCRIPTION="Ruby $RUBY_VERSION available as container is a base platform for \
building and running various Ruby $RUBY_VERSION applications and frameworks. \
Ruby is the interpreted scripting language for quick and easy object-oriented programming. \
It has many features to process text files and to do system management tasks (as in Perl). \
It is simple, straight-forward, and extensible."
LABEL summary="$SUMMARY" \
description="$DESCRIPTION" \
io.k8s.description="$DESCRIPTION" \
io.k8s.display-name="Ruby ${RUBY_VERSION}" \
io.openshift.expose-services="8080:http" \
io.openshift.tags="builder,ruby,ruby${RUBY_SHORT_VER}" \
com.redhat.component="$NAME" \
name="$FGC/$NAME" \
version="$VERSION" \
usage="s2i build https://github.com/sclorg/s2i-ruby-container.git --context-dir=${RUBY_VERSION}/test/puma-test-app/ registry.fedoraproject.org/$FGC/ruby ruby-sample-app" \
maintainer="SoftwareCollections.org <sclorg@redhat.com>"
# Install required packages
RUN INSTALL_PKGS="ruby ruby-devel rubygem-bundler rubygem-rake rubygems-devel redhat-rpm-config libffi-devel" && \
dnf install -y --setopt=tsflags=nodocs $INSTALL_PKGS && \
rpm -V $INSTALL_PKGS && \
dnf clean all
# Copy the S2I scripts from the specific language image to $STI_SCRIPTS_PATH
COPY ./s2i/bin/ $STI_SCRIPTS_PATH
# Copy extra files to the image.
COPY ./root/ /
# Drop the root user and make the content of /opt/app-root owned by user 1001
RUN chown -R 1001:0 ${APP_ROOT} && chmod -R ug+rwx ${APP_ROOT} && \
rpm-file-permissions
USER 1001
# Set the default CMD to print the usage of the language image
CMD $STI_SCRIPTS_PATH/usage

1
Dockerfile.fedora Symbolic link
View file

@ -0,0 +1 @@
Dockerfile

231
README.md Normal file
View file

@ -0,0 +1,231 @@
Ruby 2.7 container image
========================
This container image includes Ruby 2.7 as a [S2I](https://github.com/openshift/source-to-image) base image for your Ruby 2.7 applications.
Users can choose between RHEL, CentOS and Fedora based builder 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
Note: While the examples in this README are using UBI8-based images (eg. ubi8/ruby-27), you can substitute any of the ubi8 images
for any other version of the same image (RHSCL, UBI7, Centos7 or Fedora), if it exists.
Description
-----------
Ruby 2.7 available as container is a base platform for
building and running various Ruby 2.7 applications and frameworks.
Ruby is the interpreted scripting language for quick and easy object-oriented programming.
It has many features to process text files and to do system management tasks (as in Perl).
It is simple, straight-forward, and extensible.
This container image includes an npm utility, so users can use it to install JavaScript
modules for their web applications. There is no guarantee for any specific npm or nodejs
version, that is included in the image; those versions can be changed anytime and
the nodejs itself is included just to make the npm work.
Usage in Openshift
------------------
For this, we will assume that you are using the `ubi8/ruby-27 image`, available via `ruby:2.7` imagestream tag in Openshift.
Building a simple [ruby-sample-app](https://github.com/sclorg/s2i-ruby-container/tree/master/2.7/test/puma-test-app) application
in Openshift can be achieved with the following step:
```
oc new-app ruby:2.7~https://github.com/sclorg/rails-ex.git
```
**Accessing the application:**
```
$ oc get pods
$ oc exec <pod> -- curl 127.0.0.1:8080
```
Source-to-Image framework and scripts
-------------------------------------
This image supports the [Source-to-Image](https://docs.openshift.com/container-platform/4.4/builds/build-strategies.html#images-create-s2i_build-strategies)
(S2I) strategy in OpenShift. The Source-to-Image is an OpenShift framework
which makes it easy to write images that take application source code as
an input, use a builder image like this Ruby container image, and produce
a new image that runs the assembled application as an output.
To support the Source-to-Image framework, important scripts are included in the builder image:
* The `/usr/libexec/s2i/assemble` script inside the image is run to produce a new image with the application artifacts. The script takes sources of a given application and places them into appropriate directories inside the image. It utilizes some common patterns in Ruby application development (see the **Environment variables** section below).
* The `/usr/libexec/s2i/run` script is set as the default command in the resulting container image (the new image with the application artifacts). It configures web server and runs this server on port 8080.
Building an application using a Dockerfile
------------------------------------------
Compared to the Source-to-Image strategy, using a Dockerfile is a more
flexible way to build a Ruby container image with an application.
Use a Dockerfile when Source-to-Image is not sufficiently flexible for you or
when you build the image outside of the OpenShift environment.
To use the Ruby image in a Dockerfile, follow these steps:
#### 1. Pull a base builder image to build on
```
podman pull ubi8/ruby-27
```
An RHEL7 image `ubi8/ruby-27` is used in this example.
#### 2. Pull and application code
An example application available at https://github.com/sclorg/rails-ex.git is used here. Feel free to clone the repository for further experiments.
```
git clone https://github.com/sclorg/rails-ex.git app-src
```
#### 3. Prepare an application inside a container
This step usually consists of at least these parts:
* putting the application source into the container
* installing the dependencies
* setting the default command in the resulting image
For all these three parts, users can use the Source-to-Image scripts inside the image ([3.1.](#31-to-use-the-source-to-image-scripts-and-build-an-image-using-a-dockerfile-create-a-dockerfile-with-this-content)), or users can either setup all manually and use commands `ruby`, `bundle` and `rackup` explicitly in the Dockerfile ([3.2.](#32-to-use-your-own-setup-create-a-dockerfile-with-this-content))
##### 3.1 To use the Source-to-Image scripts and build an image using a Dockerfile, create a Dockerfile with this content:
```
FROM ubi8/ruby-27
# Add application sources to a directory that the assemble scriptexpects them
# and set permissions so that the container runs without root access
USER 0
ADD app-src /tmp/src
RUN chown -R 1001:0 /tmp/src
USER 1001
# Set up development mode
ENV RAILS_ENV=development
# Install the dependencies
RUN /usr/libexec/s2i/assemble
# Set the default command for the resulting image
CMD /usr/libexec/s2i/run
```
The s2i scripts are used to set-up and run common Ruby applications. More information about the scripts can be found in [Source-to-Image](#source-to-image-framework-and-scripts) section.
##### 3.2 To use your own setup, create a Dockerfile with this content:
```
FROM ubi8/ruby-27
USER 0
ADD app-src ./
RUN bundle install --path ./bundle
CMD bundle exec "rackup -P /tmp/rack.pid --host 0.0.0.0 --port 8080"
```
#### 4. Build a new image from a Dockerfile prepared in the previous step
```
podman build -t ruby-app .
```
#### 5. Run the resulting image with final application
```
podman run -d ruby-app
```
Environment variables
---------------------
To set these environment variables, you can place them as a key value pair into a `.s2i/environment`
file inside your source code repository.
* **RACK_ENV**
This variable specifies the environment where the Ruby application will be deployed (unless overwritten) - `production`, `development`, `test`.
Each level has different behaviors in terms of logging verbosity, error pages, ruby gem installation, etc.
**Note**: Application assets will be compiled only if the `RACK_ENV` is set to `production`
* **DISABLE_ASSET_COMPILATION**
This variable set to `true` indicates that the asset compilation process will be skipped. Since this only takes place
when the application is run in the `production` environment, it should only be used when assets are already compiled.
* **PUMA_MIN_THREADS**, **PUMA_MAX_THREADS**
These variables indicate the minimum and maximum threads that will be available in [Puma](https://github.com/puma/puma)'s thread pool.
* **PUMA_WORKERS**
This variable indicate the number of worker processes that will be launched. See documentation on Puma's [clustered mode](https://github.com/puma/puma#clustered-mode).
* **RUBYGEM_MIRROR**
Set this variable to use a custom RubyGems mirror URL to download required gem packages during build process.
Hot deploy
----------
In order to dynamically pick up changes made in your application source code, you need to make following steps:
* **For Ruby on Rails applications**
Run the built Rails image with the `RAILS_ENV=development` environment variable passed to the [podman](https://github.com/containers/libpod) `-e` run flag:
```
$ podman run -e RAILS_ENV=development -p 8080:8080 rails-app
```
* **For other types of Ruby applications (Sinatra, Padrino, etc.)**
Your application needs to be built with one of gems that reloads the server every time changes in source code are done inside the running container. Those gems are:
* [Shotgun](https://github.com/rtomayko/shotgun)
* [Rerun](https://github.com/alexch/rerun)
* [Rack-livereload](https://github.com/johnbintz/rack-livereload)
Please note that in order to be able to run your application in development mode, you need to modify the [S2I run script](https://github.com/openshift/source-to-image#anatomy-of-a-builder-image), so the web server is launched by the chosen gem, which checks for changes in the source code.
After you built your application image with your version of [S2I run script](https://github.com/openshift/source-to-image#anatomy-of-a-builder-image), run the image with the RACK_ENV=development environment variable passed to the [podman](https://github.com/containers/libpod) -e run flag:
```
$ podman run -e RACK_ENV=development -p 8080:8080 sinatra-app
```
To change your source code in running container, use Podman's [exec](https://github.com/containers/libpod) command:
```
$ podman exec -it <CONTAINER_ID> /bin/bash
```
After you [podman exec](https://github.com/containers/libpod) into the running container, your current
directory is set to `/opt/app-root/src`, where the source code is located.
Performance tuning
------------------
You can tune the number of threads per worker using the
`PUMA_MIN_THREADS` and `PUMA_MAX_THREADS` environment variables.
Additionally, the number of worker processes is determined by the number of CPU
cores that the container has available, as recommended by
[Puma](https://github.com/puma/puma)'s documentation. This is determined using
the cgroup [cpusets](https://www.kernel.org/doc/Documentation/cgroup-v1/cpusets.txt)
subsystem. You can specify the cores that the container is allowed to use by passing
the `--cpuset-cpus` parameter to the [podman](https://github.com/containers/libpod) run command:
```
$ podman run -e PUMA_MAX_THREADS=32 --cpuset-cpus='0-2,3,5' -p 8080:8080 sinatra-app
```
The number of workers is also limited by the memory limit that is enforced using
cgroups. The builder image assumes that you will need 50 MiB as a base and
another 15 MiB for every worker process plus 128 KiB for each thread. Note that
each worker has its own threads, so the total memory required for the whole
container is computed using the following formula:
```
50 + 15 * WORKERS + 0.125 * WORKERS * PUMA_MAX_THREADS
```
You can specify a memory limit using the `--memory` flag:
```
$ podman run -e PUMA_MAX_THREADS=32 --memory=300m -p 8080:8080 sinatra-app
```
If memory is more limiting then the number of available cores, the number of
workers is scaled down accordingly to fit the above formula. The number of
workers can also be set explicitly by setting `PUMA_WORKERS`.
See also
--------
Dockerfile and other sources are available on https://github.com/sclorg/s2i-ruby-container.
In that repository you also can find another versions of Ruby 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.

1
help.md Symbolic link
View file

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

9
root/opt/app-root/.gemrc Normal file
View file

@ -0,0 +1,9 @@
---
install: --no-document
update: --no-document
:benchmark: false
:update_sources: true
:bulk_threshold: 1000
:backtrace: true
:sources:
- https://rubygems.org/

50
root/opt/app-root/etc/puma.cfg Normal file
View file

@ -0,0 +1,50 @@
def get_max_memory()
return ENV['MEMORY_LIMIT_IN_BYTES'].to_i if ENV.has_key? 'MEMORY_LIMIT_IN_BYTES'
# Assume unlimited memory. 0.size is the number of bytes a Ruby
# Fixnum class can hold. One bit is used for sign and one is used
# by Ruby to determine whether it's a number or pointer to an object.
# That's why we subtract two bits. This expresion should therefore be
# the largest signed Fixnum possible.
(2 ** (8*0.size - 2) - 1)
end
def get_memory_per_worker()
bytes = ENV.fetch('MEMORY_BYTES_PER_WORKER', '0').to_i
if bytes == 0
# Comment describing rationale for choosing default of 256MiB/worker is below.
bytes = 256 * (2**20)
end
bytes
end
def get_min_threads()
ENV.fetch('PUMA_MIN_THREADS', '0').to_i
end
def get_max_threads()
ENV.fetch('PUMA_MAX_THREADS', '16').to_i
end
# Determine the maximum number of workers that are allowed by the available
# memory. Puma documentation recommends the maximum number of workers to be
# set to the number of cores.
# Unless we're specifically tuned otherwise, allow one worker process per 256MiB
# memory, to a maximum of 1 worker / core. Hopefully that'll be a reasonable
# starting point for average apps; if not, it's all tunable. The simple
# OpenShift ruby/rails sample app currently requires approx. 60MiB +
# 70MiB/worker before taking its first request, so hopefully a default of
# 256MiB/worker will give other simple apps reasonable default headroom.
def get_workers()
return ENV['PUMA_WORKERS'].to_i if ENV.has_key? 'PUMA_WORKERS'
cores = ENV.fetch('NUMBER_OF_CORES', '1').to_i
max_workers = get_max_memory() / get_memory_per_worker()
[cores, max_workers].min
end
environment ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'production'
threads get_min_threads(), get_max_threads()
workers get_workers()
bind 'tcp://0.0.0.0:8080'

6
root/opt/app-root/etc/scl_enable Normal file
View file

@ -0,0 +1,6 @@
# IMPORTANT: Do not add more content to this file unless you know what you are
# doing. This file is sourced everytime the shell session is opened.
#
# This will make scl collection binaries work out of box.
unset BASH_ENV PROMPT_COMMAND ENV
source scl_source enable $NODEJS_SCL rh-ruby27

67
s2i/bin/assemble Executable file
View file

@ -0,0 +1,67 @@
#!/bin/bash
function rake_assets_precompile() {
[[ "$DISABLE_ASSET_COMPILATION" == "true" ]] && return
[ ! -f Gemfile ] && return
[ ! -f Rakefile ] && return
! grep " rake " Gemfile.lock >/dev/null && return
! bundle exec 'rake -T' | grep "assets:precompile" >/dev/null && return
echo "---> Starting asset compilation ..."
bundle exec "rake assets:precompile"
}
set -e
export RACK_ENV=${RACK_ENV:-"production"}
if [ -n "$RUBYGEM_MIRROR" ]; then
bundle config mirror.https://rubygems.org $RUBYGEM_MIRROR
fi
shopt -s dotglob
echo "---> Installing application source ..."
mv /tmp/src/* ./
# Change the npm registry mirror if provided
if [ -n "$NPM_MIRROR" ]; then
npm config set registry $NPM_MIRROR
fi
echo "---> Building your Ruby application from source ..."
if [ -f Gemfile ]; then
ADDTL_BUNDLE_ARGS="--retry 2"
if [ -f Gemfile.lock ]; then
ADDTL_BUNDLE_ARGS+=" --deployment"
fi
if [[ "$RAILS_ENV" == "development" || "$RACK_ENV" == "development" ]]; then
BUNDLE_WITHOUT=${BUNDLE_WITHOUT:-"test"}
elif [[ "$RAILS_ENV" == "test" || "$RACK_ENV" == "test" ]]; then
BUNDLE_WITHOUT=${BUNDLE_WITHOUT:-"development"}
else
BUNDLE_WITHOUT=${BUNDLE_WITHOUT:-"development:test"}
fi
if [ -n "$BUNDLE_WITHOUT" ]; then
ADDTL_BUNDLE_ARGS+=" --without $BUNDLE_WITHOUT"
fi
echo "---> Running 'bundle install ${ADDTL_BUNDLE_ARGS}' ..."
bundle install --path ./bundle ${ADDTL_BUNDLE_ARGS}
echo "---> Cleaning up unused ruby gems ..."
bundle clean -V
fi
if ! bundle exec rackup -h &>/dev/null; then
echo "WARNING: Rubygem Rack is not installed in the present image."
echo " Add rack to your Gemfile in order to start the web server."
fi
if [[ "$RAILS_ENV" == "production" || "$RACK_ENV" == "production" ]]; then
rake_assets_precompile
fi
# Fix source directory permissions
fix-permissions ./

39
s2i/bin/run Executable file
View file

@ -0,0 +1,39 @@
#!/bin/bash
function is_puma_installed() {
[ ! -f Gemfile.lock ] && return 1
grep ' puma ' Gemfile.lock >/dev/null
}
set -e
function check_number() {
if [[ ! "$2" =~ ^[0-9]+$ ]]; then
echo "$1 needs to be a non-negative number"
exit 1
fi
}
check_number PUMA_WORKERS "${PUMA_WORKERS:-0}"
check_number PUMA_MIN_THREADS "${PUMA_MIN_THREADS:-0}"
check_number PUMA_MAX_THREADS "${PUMA_MAX_THREADS:-0}"
export RACK_ENV=${RACK_ENV:-"production"}
if is_puma_installed; then
export_vars=$(cgroup-limits) ; export $export_vars
exec bundle exec "puma --config ../etc/puma.cfg"
else
echo "You might consider adding 'puma' into your Gemfile."
if bundle exec rackup -h &>/dev/null; then
if [ -f Gemfile ]; then
exec bundle exec "rackup -E ${RAILS_ENV:-$RACK_ENV} -P /tmp/rack.pid --host 0.0.0.0 --port 8080"
else
exec rackup -E "${RAILS_ENV:-$RACK_ENV}" -P /tmp/rack.pid --host 0.0.0.0 --port 8080
fi
else
echo "ERROR: Rubygem Rack is not installed in the present image."
echo " Add rack to your Gemfile in order to start the web server."
fi
fi

18
s2i/bin/usage Executable file
View file

@ -0,0 +1,18 @@
#!/bin/sh
DISTRO="`grep ^ID= /etc/*-release | cut -d'"' -f2`"
cat <<EOF
This is a S2I ruby-${RUBY_VERSION} ${DISTRO} base image:
To use it in Openshift, run:
oc new-app ruby:${RUBY_VERSION}~https://github.com/sclorg/s2i-ruby-container.git --context-dir=${RUBY_VERSION}/test/puma-test-app/
You can then run the resulting image via:
$ oc get pods
$ oc exec <pod> -- curl 127.0.0.1:8080
Alternatively, to run the image directly using podman or docker, or how to use it as a parent image in a Dockerfile, see documentation at
https://github.com/sclorg/s2i-ruby-container/blob/master/${RUBY_VERSION}/README.md
EOF

7
test/examples/from-dockerfile/Dockerfile Normal file
View file

@ -0,0 +1,7 @@
FROM ubi8/ruby-27
ADD app-src ./
RUN bundle install --path ./bundle
CMD exec bundle exec "rackup -P /tmp/rack.pid --host 0.0.0.0 --port 8080"

15
test/examples/from-dockerfile/Dockerfile.s2i Normal file
View file

@ -0,0 +1,15 @@
FROM ubi8/ruby-27
# Add application sources to a directory that the assemble script expects them
# and set permissions so that the container runs without root access
USER 0
ADD app-src /tmp/src
RUN chown -R 1001:0 /tmp/src
USER 1001
ENV RAILS_ENV=development
# Install the dependencies
RUN /usr/libexec/s2i/assemble
# Set the default command for the resulting image
CMD /usr/libexec/s2i/run

21
test/examples/from-dockerfile/README.md Normal file
View file

@ -0,0 +1,21 @@
Dockerfile examples
===================
This directory contains example Dockerfiles that demonstrate how to use the image with a Dockerfile and `docker build`.
For demonstration, we use an application code available at https://github.com/sclorg/rails-ex.git.
Pull the source to the local machine first:
```
git clone https://github.com/sclorg/rails-ex.git app-src
```
Then, build a new image from a Dockerfile in this directory:
```
docker build -f Dockerfile -t ruby-app .
```
And run the resulting image with the final application:
```
docker run -ti --rm ruby-app
```

612
test/examples/rails-postgresql-persistent.json Normal file
View file

@ -0,0 +1,612 @@
{
"kind": "Template",
"apiVersion": "v1",
"metadata": {
"name": "rails-pgsql-persistent",
"annotations": {
"openshift.io/display-name": "Rails + PostgreSQL (Persistent)",
"description": "An example Rails application with a PostgreSQL database. For more information about using this template, including OpenShift considerations, see https://github.com/sclorg/rails-ex/blob/master/README.md.",
"tags": "quickstart,ruby,rails",
"iconClass": "icon-ruby",
"template.openshift.io/long-description": "This template defines resources needed to develop a Rails application, including a build configuration, application deployment configuration, and database deployment configuration.",
"template.openshift.io/provider-display-name": "Red Hat, Inc.",
"template.openshift.io/documentation-url": "https://github.com/sclorg/rails-ex",
"template.openshift.io/support-url": "https://access.redhat.com"
}
},
"message": "The following service(s) have been created in your project: ${NAME}, ${DATABASE_SERVICE_NAME}.\n\nFor more information about using this template, including OpenShift considerations, see https://github.com/sclorg/rails-ex/blob/master/README.md.",
"labels": {
"template": "rails-pgsql-persistent"
},
"objects": [
{
"kind": "Secret",
"apiVersion": "v1",
"metadata": {
"name": "${NAME}",
"annotations": {
"template.openshift.io/expose-username": "{.data['application-user']}",
"template.openshift.io/expose-password": "{.data['application-password']}"
}
},
"stringData" : {
"database-user" : "${DATABASE_USER}",
"database-password" : "${DATABASE_PASSWORD}",
"application-user" : "${APPLICATION_USER}",
"application-password" : "${APPLICATION_PASSWORD}",
"keybase" : "${SECRET_KEY_BASE}"
}
},
{
"kind": "Service",
"apiVersion": "v1",
"metadata": {
"name": "${NAME}",
"annotations": {
"description": "Exposes and load balances the application pods",
"service.alpha.openshift.io/dependencies": "[{\"name\": \"${DATABASE_SERVICE_NAME}\", \"kind\": \"Service\"}]"
}
},
"spec": {
"ports": [
{
"name": "web",
"port": 8080,
"targetPort": 8080
}
],
"selector": {
"name": "${NAME}"
}
}
},
{
"kind": "Route",
"apiVersion": "v1",
"metadata": {
"name": "${NAME}",
"annotations": {
"template.openshift.io/expose-uri": "http://{.spec.host}{.spec.path}"
}
},
"spec": {
"host": "${APPLICATION_DOMAIN}",
"to": {
"kind": "Service",
"name": "${NAME}"
}
}
},
{
"kind": "ImageStream",
"apiVersion": "v1",
"metadata": {
"name": "${NAME}",
"annotations": {
"description": "Keeps track of changes in the application image"
}
}
},
{
"kind": "BuildConfig",
"apiVersion": "v1",
"metadata": {
"name": "${NAME}",
"annotations": {
"description": "Defines how to build the application",
"template.alpha.openshift.io/wait-for-ready": "true"
}
},
"spec": {
"source": {
"type": "Git",
"git": {
"uri": "${SOURCE_REPOSITORY_URL}",
"ref": "${SOURCE_REPOSITORY_REF}"
},
"contextDir": "${CONTEXT_DIR}"
},
"strategy": {
"type": "Source",
"sourceStrategy": {
"from": {
"kind": "ImageStreamTag",
"namespace": "${NAMESPACE}",
"name": "ruby:2.5"
},
"env": [
{
"name": "RUBYGEM_MIRROR",
"value": "${RUBYGEM_MIRROR}"
}
]
}
},
"output": {
"to": {
"kind": "ImageStreamTag",
"name": "${NAME}:latest"
}
},
"triggers": [
{
"type": "ImageChange"
},
{
"type": "ConfigChange"
},
{
"type": "GitHub",
"github": {
"secret": "${GITHUB_WEBHOOK_SECRET}"
}
}
],
"postCommit": {
"script": "bundle exec rake test"
}
}
},
{
"kind": "DeploymentConfig",
"apiVersion": "v1",
"metadata": {
"name": "${NAME}",
"annotations": {
"description": "Defines how to deploy the application server",
"template.alpha.openshift.io/wait-for-ready": "true"
}
},
"spec": {
"strategy": {
"type": "Recreate",
"recreateParams": {
"pre": {
"failurePolicy": "Abort",
"execNewPod": {
"command": [
"./migrate-database.sh"
],
"containerName": "${NAME}"
}
}
}
},
"triggers": [
{
"type": "ImageChange",
"imageChangeParams": {
"automatic": true,
"containerNames": [
"${NAME}"
],
"from": {
"kind": "ImageStreamTag",
"name": "${NAME}:latest"
}
}
},
{
"type": "ConfigChange"
}
],
"replicas": 1,
"selector": {
"name": "${NAME}"
},
"template": {
"metadata": {
"name": "${NAME}",
"labels": {
"name": "${NAME}"
}
},
"spec": {
"containers": [
{
"name": "${NAME}",
"image": " ",
"ports": [
{
"containerPort": 8080
}
],
"readinessProbe": {
"timeoutSeconds": 3,
"initialDelaySeconds": 5,
"httpGet": {
"path": "/articles",
"port": 8080
}
},
"livenessProbe": {
"timeoutSeconds": 3,
"initialDelaySeconds": 10,
"httpGet": {
"path": "/articles",
"port": 8080
}
},
"env": [
{
"name": "DATABASE_SERVICE_NAME",
"value": "${DATABASE_SERVICE_NAME}"
},
{
"name": "POSTGRESQL_USER",
"valueFrom": {
"secretKeyRef" : {
"name" : "${NAME}",
"key" : "database-user"
}
}
},
{
"name": "POSTGRESQL_PASSWORD",
"valueFrom": {
"secretKeyRef" : {
"name" : "${NAME}",
"key" : "database-password"
}
}
},
{
"name": "SECRET_KEY_BASE",
"valueFrom": {
"secretKeyRef" : {
"name" : "${NAME}",
"key" : "keybase"
}
}
},
{
"name": "POSTGRESQL_DATABASE",
"value": "${DATABASE_NAME}"
},
{
"name": "POSTGRESQL_MAX_CONNECTIONS",
"value": "${POSTGRESQL_MAX_CONNECTIONS}"
},
{
"name": "POSTGRESQL_SHARED_BUFFERS",
"value": "${POSTGRESQL_SHARED_BUFFERS}"
},
{
"name": "APPLICATION_DOMAIN",
"value": "${APPLICATION_DOMAIN}"
},
{
"name": "APPLICATION_USER",
"valueFrom": {
"secretKeyRef" : {
"name" : "${NAME}",
"key" : "application-user"
}
}
},
{
"name": "APPLICATION_PASSWORD",
"valueFrom": {
"secretKeyRef" : {
"name" : "${NAME}",
"key" : "application-password"
}
}
},
{
"name": "RAILS_ENV",
"value": "${RAILS_ENV}"
}
],
"resources": {
"limits": {
"memory": "${MEMORY_LIMIT}"
}
}
}
]
}
}
}
},
{
"kind": "PersistentVolumeClaim",
"apiVersion": "v1",
"metadata": {
"name": "${DATABASE_SERVICE_NAME}"
},
"spec": {
"accessModes": [
"ReadWriteOnce"
],
"resources": {
"requests": {
"storage": "${VOLUME_CAPACITY}"
}
}
}
},
{
"kind": "Service",
"apiVersion": "v1",
"metadata": {
"name": "${DATABASE_SERVICE_NAME}",
"annotations": {
"description": "Exposes the database server"
}
},
"spec": {
"ports": [
{
"name": "postgresql",
"port": 5432,
"targetPort": 5432
}
],
"selector": {
"name": "${DATABASE_SERVICE_NAME}"
}
}
},
{
"kind": "DeploymentConfig",
"apiVersion": "v1",
"metadata": {
"name": "${DATABASE_SERVICE_NAME}",
"annotations": {
"description": "Defines how to deploy the database",
"template.alpha.openshift.io/wait-for-ready": "true"
}
},
"spec": {
"strategy": {
"type": "Recreate"
},
"triggers": [
{
"type": "ImageChange",
"imageChangeParams": {
"automatic": true,
"containerNames": [
"postgresql"
],
"from": {
"kind": "ImageStreamTag",
"namespace": "${NAMESPACE}",
"name": "postgresql:10"
}
}
},
{
"type": "ConfigChange"
}
],
"replicas": 1,
"selector": {
"name": "${DATABASE_SERVICE_NAME}"
},
"template": {
"metadata": {
"name": "${DATABASE_SERVICE_NAME}",
"labels": {
"name": "${DATABASE_SERVICE_NAME}"
}
},
"spec": {
"volumes": [
{
"name": "${DATABASE_SERVICE_NAME}-data",
"persistentVolumeClaim": {
"claimName": "${DATABASE_SERVICE_NAME}"
}
}
],
"containers": [
{
"name": "postgresql",
"image": " ",
"ports": [
{
"containerPort": 5432
}
],
"readinessProbe": {
"timeoutSeconds": 1,
"initialDelaySeconds": 5,
"exec": {
"command": [ "/bin/sh", "-i", "-c", "psql -h 127.0.0.1 -U ${POSTGRESQL_USER} -q -d ${POSTGRESQL_DATABASE} -c 'SELECT 1'"]
}
},
"livenessProbe": {
"timeoutSeconds": 1,
"initialDelaySeconds": 30,
"tcpSocket": {
"port": 5432
}
},
"volumeMounts": [
{
"name": "${DATABASE_SERVICE_NAME}-data",
"mountPath": "/var/lib/pgsql/data"
}
],
"env": [
{
"name": "POSTGRESQL_USER",
"valueFrom": {
"secretKeyRef" : {
"name" : "${NAME}",
"key" : "database-user"
}
}
},
{
"name": "POSTGRESQL_PASSWORD",
"valueFrom": {
"secretKeyRef" : {
"name" : "${NAME}",
"key" : "database-password"
}
}
},
{
"name": "POSTGRESQL_DATABASE",
"value": "${DATABASE_NAME}"
},
{
"name": "POSTGRESQL_MAX_CONNECTIONS",
"value": "${POSTGRESQL_MAX_CONNECTIONS}"
},
{
"name": "POSTGRESQL_SHARED_BUFFERS",
"value": "${POSTGRESQL_SHARED_BUFFERS}"
}
],
"resources": {
"limits": {
"memory": "${MEMORY_POSTGRESQL_LIMIT}"
}
}
}
]
}
}
}
}
],
"parameters": [
{
"name": "NAME",
"displayName": "Name",
"description": "The name assigned to all of the frontend objects defined in this template.",
"required": true,
"value": "rails-pgsql-persistent"
},
{
"name": "NAMESPACE",
"displayName": "Namespace",
"required": true,
"description": "The OpenShift Namespace where the ImageStream resides.",
"value": "openshift"
},
{
"name": "MEMORY_LIMIT",
"displayName": "Memory Limit",
"required": true,
"description": "Maximum amount of memory the Rails container can use.",
"value": "512Mi"
},
{
"name": "MEMORY_POSTGRESQL_LIMIT",
"displayName": "Memory Limit (PostgreSQL)",
"required": true,
"description": "Maximum amount of memory the PostgreSQL container can use.",
"value": "512Mi"
},
{
"name": "VOLUME_CAPACITY",
"displayName": "Volume Capacity",
"description": "Volume space available for data, e.g. 512Mi, 2Gi",
"value": "1Gi",
"required": true
},
{
"name": "SOURCE_REPOSITORY_URL",
"displayName": "Git Repository URL",
"required": true,
"description": "The URL of the repository with your application source code.",
"value": "https://github.com/sclorg/rails-ex.git"
},
{
"name": "SOURCE_REPOSITORY_REF",
"displayName": "Git Reference",
"description": "Set this to a branch name, tag or other ref of your repository if you are not using the default branch."
},
{
"name": "CONTEXT_DIR",
"displayName": "Context Directory",
"description": "Set this to the relative path to your project if it is not in the root of your repository."
},
{
"name": "APPLICATION_DOMAIN",
"displayName": "Application Hostname",
"description": "The exposed hostname that will route to the Rails service, if left blank a value will be defaulted.",
"value": ""
},
{
"name": "GITHUB_WEBHOOK_SECRET",
"displayName": "GitHub Webhook Secret",
"description": "Github trigger secret. A difficult to guess string encoded as part of the webhook URL. Not encrypted.",
"generate": "expression",
"from": "[a-zA-Z0-9]{40}"
},
{
"name": "SECRET_KEY_BASE",
"displayName": "Secret Key",
"description": "Your secret key for verifying the integrity of signed cookies.",
"generate": "expression",
"from": "[a-z0-9]{127}"
},
{
"name": "APPLICATION_USER",
"displayName": "Application Username",
"required": true,
"description": "The application user that is used within the sample application to authorize access on pages.",
"value": "openshift"
},
{
"name": "APPLICATION_PASSWORD",
"displayName": "Application Password",
"required": true,
"description": "The application password that is used within the sample application to authorize access on pages.",
"value": "secret"
},
{
"name": "RAILS_ENV",
"displayName": "Rails Environment",
"required": true,
"description": "Environment under which the sample application will run. Could be set to production, development or test.",
"value": "production"
},
{
"name": "DATABASE_SERVICE_NAME",
"required": true,
"displayName": "Database Service Name",
"value": "postgresql"
},
{
"name": "DATABASE_USER",
"displayName": "Database Username",
"generate": "expression",
"from": "user[A-Z0-9]{3}"
},
{
"name": "DATABASE_PASSWORD",
"displayName": "Database Password",
"generate": "expression",
"from": "[a-zA-Z0-9]{8}"
},
{
"name": "DATABASE_NAME",
"required": true,
"displayName": "Database Name",
"value": "root"
},
{
"name": "POSTGRESQL_MAX_CONNECTIONS",
"displayName": "Maximum Database Connections",
"value": "100"
},
{
"name": "POSTGRESQL_SHARED_BUFFERS",
"displayName": "Shared Buffer Amount",
"value": "12MB"
},
{
"name": "RUBYGEM_MIRROR",
"displayName": "Custom RubyGems Mirror URL",
"description": "The custom RubyGems mirror URL",
"value": ""
}
]
}

586
test/examples/rails-postgresql.json Normal file
View file

@ -0,0 +1,586 @@
{
"kind": "Template",
"apiVersion": "v1",
"metadata": {
"name": "rails-postgresql-example",
"annotations": {
"openshift.io/display-name": "Rails + PostgreSQL (Ephemeral)",
"description": "An example Rails application with a PostgreSQL database. For more information about using this template, including OpenShift considerations, see https://github.com/sclorg/rails-ex/blob/master/README.md.\n\nWARNING: Any data stored will be lost upon pod destruction. Only use this template for testing.",
"tags": "quickstart,ruby,rails",
"iconClass": "icon-ruby",
"template.openshift.io/long-description": "This template defines resources needed to develop a Rails application, including a build configuration, application deployment configuration, and database deployment configuration. The database is stored in non-persistent storage, so this configuration should be used for experimental purposes only.",
"template.openshift.io/provider-display-name": "Red Hat, Inc.",
"template.openshift.io/documentation-url": "https://github.com/sclorg/rails-ex",
"template.openshift.io/support-url": "https://access.redhat.com"
}
},
"message": "The following service(s) have been created in your project: ${NAME}, ${DATABASE_SERVICE_NAME}.\n\nFor more information about using this template, including OpenShift considerations, see https://github.com/sclorg/rails-ex/blob/master/README.md.",
"labels": {
"template": "rails-postgresql-example"
},
"objects": [
{
"kind": "Secret",
"apiVersion": "v1",
"metadata": {
"name": "${NAME}",
"annotations": {
"template.openshift.io/expose-username": "{.data['application-user']}",
"template.openshift.io/expose-password": "{.data['application-password']}"
}
},
"stringData" : {
"database-user" : "${DATABASE_USER}",
"database-password" : "${DATABASE_PASSWORD}",
"application-user" : "${APPLICATION_USER}",
"application-password" : "${APPLICATION_PASSWORD}",
"keybase" : "${SECRET_KEY_BASE}"
}
},
{
"kind": "Service",
"apiVersion": "v1",
"metadata": {
"name": "${NAME}",
"annotations": {
"description": "Exposes and load balances the application pods",
"service.alpha.openshift.io/dependencies": "[{\"name\": \"${DATABASE_SERVICE_NAME}\", \"kind\": \"Service\"}]"
}
},
"spec": {
"ports": [
{
"name": "web",
"port": 8080,
"targetPort": 8080
}
],
"selector": {
"name": "${NAME}"
}
}
},
{
"kind": "Route",
"apiVersion": "v1",
"metadata": {
"name": "${NAME}",
"annotations": {
"template.openshift.io/expose-uri": "http://{.spec.host}{.spec.path}"
}
},
"spec": {
"host": "${APPLICATION_DOMAIN}",
"to": {
"kind": "Service",
"name": "${NAME}"
}
}
},
{
"kind": "ImageStream",
"apiVersion": "v1",
"metadata": {
"name": "${NAME}",
"annotations": {
"description": "Keeps track of changes in the application image"
}
}
},
{
"kind": "BuildConfig",
"apiVersion": "v1",
"metadata": {
"name": "${NAME}",
"annotations": {
"description": "Defines how to build the application",
"template.alpha.openshift.io/wait-for-ready": "true"
}
},
"spec": {
"source": {
"type": "Git",
"git": {
"uri": "${SOURCE_REPOSITORY_URL}",
"ref": "${SOURCE_REPOSITORY_REF}"
},
"contextDir": "${CONTEXT_DIR}"
},
"strategy": {
"type": "Source",
"sourceStrategy": {
"from": {
"kind": "ImageStreamTag",
"namespace": "${NAMESPACE}",
"name": "ruby:2.5"
},
"env": [
{
"name": "RUBYGEM_MIRROR",
"value": "${RUBYGEM_MIRROR}"
}
]
}
},
"output": {
"to": {
"kind": "ImageStreamTag",
"name": "${NAME}:latest"
}
},
"triggers": [
{
"type": "ImageChange"
},
{
"type": "ConfigChange"
},
{
"type": "GitHub",
"github": {
"secret": "${GITHUB_WEBHOOK_SECRET}"
}
}
],
"postCommit": {
"script": "bundle exec rake test"
}
}
},
{
"kind": "DeploymentConfig",
"apiVersion": "v1",
"metadata": {
"name": "${NAME}",
"annotations": {
"description": "Defines how to deploy the application server",
"template.alpha.openshift.io/wait-for-ready": "true"
}
},
"spec": {
"strategy": {
"type": "Recreate",
"recreateParams": {
"pre": {
"failurePolicy": "Abort",
"execNewPod": {
"command": [
"./migrate-database.sh"
],
"containerName": "${NAME}"
}
}
}
},
"triggers": [
{
"type": "ImageChange",
"imageChangeParams": {
"automatic": true,
"containerNames": [
"${NAME}"
],
"from": {
"kind": "ImageStreamTag",
"name": "${NAME}:latest"
}
}
},
{
"type": "ConfigChange"
}
],
"replicas": 1,
"selector": {
"name": "${NAME}"
},
"template": {
"metadata": {
"name": "${NAME}",
"labels": {
"name": "${NAME}"
}
},
"spec": {
"containers": [
{
"name": "${NAME}",
"image": " ",
"ports": [
{
"containerPort": 8080
}
],
"readinessProbe": {
"timeoutSeconds": 3,
"initialDelaySeconds": 5,
"httpGet": {
"path": "/articles",
"port": 8080
}
},
"livenessProbe": {
"timeoutSeconds": 3,
"initialDelaySeconds": 10,
"httpGet": {
"path": "/articles",
"port": 8080
}
},
"env": [
{
"name": "DATABASE_SERVICE_NAME",
"value": "${DATABASE_SERVICE_NAME}"
},
{
"name": "POSTGRESQL_USER",
"valueFrom": {
"secretKeyRef" : {
"name" : "${NAME}",
"key" : "database-user"
}
}
},
{
"name": "POSTGRESQL_PASSWORD",
"valueFrom": {
"secretKeyRef" : {
"name" : "${NAME}",
"key" : "database-password"
}
}
},
{
"name": "POSTGRESQL_DATABASE",
"value": "${DATABASE_NAME}"
},
{
"name": "SECRET_KEY_BASE",
"valueFrom": {
"secretKeyRef" : {
"name" : "${NAME}",
"key" : "keybase"
}
}
},
{
"name": "POSTGRESQL_MAX_CONNECTIONS",
"value": "${POSTGRESQL_MAX_CONNECTIONS}"
},
{
"name": "POSTGRESQL_SHARED_BUFFERS",
"value": "${POSTGRESQL_SHARED_BUFFERS}"
},
{
"name": "APPLICATION_DOMAIN",
"value": "${APPLICATION_DOMAIN}"
},
{
"name": "APPLICATION_USER",
"valueFrom": {
"secretKeyRef" : {
"name" : "${NAME}",
"key" : "application-user"
}
}
},
{
"name": "APPLICATION_PASSWORD",
"valueFrom": {
"secretKeyRef" : {
"name" : "${NAME}",
"key" : "application-password"
}
}
},
{
"name": "RAILS_ENV",
"value": "${RAILS_ENV}"
}
],
"resources": {
"limits": {
"memory": "${MEMORY_LIMIT}"
}
}
}
]
}
}
}
},
{
"kind": "Service",
"apiVersion": "v1",
"metadata": {
"name": "${DATABASE_SERVICE_NAME}",
"annotations": {
"description": "Exposes the database server"
}
},
"spec": {
"ports": [
{
"name": "postgresql",
"port": 5432,
"targetPort": 5432
}
],
"selector": {
"name": "${DATABASE_SERVICE_NAME}"
}
}
},
{
"kind": "DeploymentConfig",
"apiVersion": "v1",
"metadata": {
"name": "${DATABASE_SERVICE_NAME}",
"annotations": {
"description": "Defines how to deploy the database",
"template.alpha.openshift.io/wait-for-ready": "true"
}
},
"spec": {
"strategy": {
"type": "Recreate"
},
"triggers": [
{
"type": "ImageChange",
"imageChangeParams": {
"automatic": true,
"containerNames": [
"postgresql"
],
"from": {
"kind": "ImageStreamTag",
"namespace": "${NAMESPACE}",
"name": "postgresql:10"
}
}
},
{
"type": "ConfigChange"
}
],
"replicas": 1,
"selector": {
"name": "${DATABASE_SERVICE_NAME}"
},
"template": {
"metadata": {
"name": "${DATABASE_SERVICE_NAME}",
"labels": {
"name": "${DATABASE_SERVICE_NAME}"
}
},
"spec": {
"volumes": [
{
"name": "data",
"emptyDir": {}
}
],
"containers": [
{
"name": "postgresql",
"image": " ",
"ports": [
{
"containerPort": 5432
}
],
"readinessProbe": {
"timeoutSeconds": 1,
"initialDelaySeconds": 5,
"exec": {
"command": [ "/bin/sh", "-i", "-c", "psql -h 127.0.0.1 -U ${POSTGRESQL_USER} -q -d ${POSTGRESQL_DATABASE} -c 'SELECT 1'"]
}
},
"livenessProbe": {
"timeoutSeconds": 1,
"initialDelaySeconds": 30,
"tcpSocket": {
"port": 5432
}
},
"volumeMounts": [
{
"name": "data",
"mountPath": "/var/lib/pgsql/data"
}
],
"env": [
{
"name": "POSTGRESQL_USER",
"valueFrom": {
"secretKeyRef" : {
"name" : "${NAME}",
"key" : "database-user"
}
}
},
{
"name": "POSTGRESQL_PASSWORD",
"valueFrom": {
"secretKeyRef" : {
"name" : "${NAME}",
"key" : "database-password"
}
}
},
{
"name": "POSTGRESQL_DATABASE",
"value": "${DATABASE_NAME}"
},
{
"name": "POSTGRESQL_MAX_CONNECTIONS",
"value": "${POSTGRESQL_MAX_CONNECTIONS}"
},
{
"name": "POSTGRESQL_SHARED_BUFFERS",
"value": "${POSTGRESQL_SHARED_BUFFERS}"
}
],
"resources": {
"limits": {
"memory": "${MEMORY_POSTGRESQL_LIMIT}"
}
}
}
]
}
}
}
}
],
"parameters": [
{
"name": "NAME",
"displayName": "Name",
"description": "The name assigned to all of the frontend objects defined in this template.",
"required": true,
"value": "rails-postgresql-example"
},
{
"name": "NAMESPACE",
"displayName": "Namespace",
"required": true,
"description": "The OpenShift Namespace where the ImageStream resides.",
"value": "openshift"
},
{
"name": "MEMORY_LIMIT",
"displayName": "Memory Limit",
"required": true,
"description": "Maximum amount of memory the Rails container can use.",
"value": "512Mi"
},
{
"name": "MEMORY_POSTGRESQL_LIMIT",
"displayName": "Memory Limit (PostgreSQL)",
"required": true,
"description": "Maximum amount of memory the PostgreSQL container can use.",
"value": "512Mi"
},
{
"name": "SOURCE_REPOSITORY_URL",
"displayName": "Git Repository URL",
"required": true,
"description": "The URL of the repository with your application source code.",
"value": "https://github.com/sclorg/rails-ex.git"
},
{
"name": "SOURCE_REPOSITORY_REF",
"displayName": "Git Reference",
"description": "Set this to a branch name, tag or other ref of your repository if you are not using the default branch."
},
{
"name": "CONTEXT_DIR",
"displayName": "Context Directory",
"description": "Set this to the relative path to your project if it is not in the root of your repository."
},
{
"name": "APPLICATION_DOMAIN",
"displayName": "Application Hostname",
"description": "The exposed hostname that will route to the Rails service, if left blank a value will be defaulted.",
"value": ""
},
{
"name": "GITHUB_WEBHOOK_SECRET",
"displayName": "GitHub Webhook Secret",
"description": "Github trigger secret. A difficult to guess string encoded as part of the webhook URL. Not encrypted.",
"generate": "expression",
"from": "[a-zA-Z0-9]{40}"
},
{
"name": "SECRET_KEY_BASE",
"displayName": "Secret Key",
"description": "Your secret key for verifying the integrity of signed cookies.",
"generate": "expression",
"from": "[a-z0-9]{127}"
},
{
"name": "APPLICATION_USER",
"displayName": "Application Username",
"required": true,
"description": "The application user that is used within the sample application to authorize access on pages.",
"value": "openshift"
},
{
"name": "APPLICATION_PASSWORD",
"displayName": "Application Password",
"required": true,
"description": "The application password that is used within the sample application to authorize access on pages.",
"value": "secret"
},
{
"name": "RAILS_ENV",
"displayName": "Rails Environment",
"required": true,
"description": "Environment under which the sample application will run. Could be set to production, development or test.",
"value": "production"
},
{
"name": "DATABASE_SERVICE_NAME",
"required": true,
"displayName": "Database Service Name",
"value": "postgresql"
},
{
"name": "DATABASE_USER",
"displayName": "Database Username",
"generate": "expression",
"from": "user[A-Z0-9]{3}"
},
{
"name": "DATABASE_PASSWORD",
"displayName": "Database Password",
"generate": "expression",
"from": "[a-zA-Z0-9]{8}"
},
{
"name": "DATABASE_NAME",
"required": true,
"displayName": "Database Name",
"value": "root"
},
{
"name": "POSTGRESQL_MAX_CONNECTIONS",
"displayName": "Maximum Database Connections",
"value": "100"
},
{
"name": "POSTGRESQL_SHARED_BUFFERS",
"displayName": "Shared Buffer Amount",
"value": "12MB"
},
{
"name": "RUBYGEM_MIRROR",
"displayName": "Custom RubyGems Mirror URL",
"description": "The custom RubyGems mirror URL",
"value": ""
}
]
}

192
test/imagestreams/ruby-centos.json Normal file
View file

@ -0,0 +1,192 @@
{
"kind": "ImageStream",
"apiVersion": "v1",
"metadata": {
"name": "ruby",
"annotations": {
"openshift.io/display-name": "Ruby"
}
},
"spec": {
"tags": [
{
"name": "latest",
"annotations": {
"openshift.io/display-name": "Ruby (Latest)",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby applications on UBI. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/tree/master/2.6/README.md.\n\nWARNING: By selecting this tag, your application will automatically update to use the latest version of Ruby available on OpenShift, including major version updates.",
"iconClass": "icon-ruby",
"tags": "builder,ruby",
"supports": "ruby",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "ImageStreamTag",
"name": "2.7-ubi8"
},
"referencePolicy": {
"type": "Local"
}
},
{
"name": "2.7-ubi8",
"annotations": {
"openshift.io/display-name": "Ruby 2.7 (UBI 8)",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby 2.7 applications on UBI 8. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/blob/master/2.7/README.md.",
"iconClass": "icon-ruby",
"tags": "builder,ruby",
"supports": "ruby:2.7,ruby",
"version": "2.7",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "DockerImage",
"name": "registry.access.redhat.com/ubi8/ruby-27:latest"
},
"referencePolicy": {
"type": "Local"
}
},
{
"name": "3.0-ubi7",
"annotations": {
"openshift.io/display-name": "Ruby 3.0 (UBI 7)",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby 3.0 applications on UBI 7. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/blob/master/3.0/README.md.",
"iconClass": "icon-ruby",
"tags": "builder,ruby",
"supports": "ruby:3.0,ruby",
"version": "3.0",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "DockerImage",
"name": "registry.access.redhat.com/ubi7/ruby-30:latest"
},
"referencePolicy": {
"type": "Local"
}
},
{
"name": "2.7-ubi7",
"annotations": {
"openshift.io/display-name": "Ruby 2.7 (UBI 7)",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby 2.7 applications on UBI 7. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/blob/master/2.7/README.md.",
"iconClass": "icon-ruby",
"tags": "builder,ruby",
"supports": "ruby:2.7,ruby",
"version": "2.7",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "DockerImage",
"name": "registry.access.redhat.com/ubi7/ruby-27:latest"
},
"referencePolicy": {
"type": "Local"
}
},
{
"name": "2.7",
"annotations": {
"openshift.io/display-name": "Ruby 2.7",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby applications on CentOS 7. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/tree/master/2.7/README.md.\n\nWARNING: By selecting this tag, your application will automatically update to use the latest version of Ruby available on OpenShift, including major version updates.",
"iconClass": "icon-ruby",
"tags": "builder,ruby,hidden",
"supports": "ruby",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "DockerImage",
"name": "quay.io/centos7/ruby-27-centos7:latest"
},
"referencePolicy": {
"type": "Local"
}
},
{
"name": "2.6-ubi8",
"annotations": {
"openshift.io/display-name": "Ruby 2.6 (UBI 8)",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby 2.6 applications on UBI 8. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/blob/master/2.6/README.md.",
"iconClass": "icon-ruby",
"tags": "builder,ruby",
"supports": "ruby:2.6,ruby",
"version": "2.6",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "DockerImage",
"name": "registry.access.redhat.com/ubi8/ruby-26:latest"
},
"referencePolicy": {
"type": "Local"
}
},
{
"name": "2.6-ubi7",
"annotations": {
"openshift.io/display-name": "Ruby 2.6 (UBI 7)",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby 2.6 applications on UBI 7. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/blob/master/2.6/README.md.",
"iconClass": "icon-ruby",
"tags": "builder,ruby",
"supports": "ruby:2.6,ruby",
"version": "2.6",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "DockerImage",
"name": "registry.access.redhat.com/ubi7/ruby-26:latest"
},
"referencePolicy": {
"type": "Local"
}
},
{
"name": "2.6",
"annotations": {
"openshift.io/display-name": "Ruby 2.6",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby 2.6 applications on CentOS 7. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/blob/master/2.6/README.md.",
"iconClass": "icon-ruby",
"tags": "builder,ruby,hidden",
"supports": "ruby:2.6,ruby",
"version": "2.6",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "DockerImage",
"name": "quay.io/centos7/ruby-26-centos7:latest"
},
"referencePolicy": {
"type": "Local"
}
},
{
"name": "2.5-ubi8",
"annotations": {
"openshift.io/display-name": "Ruby 2.5 (UBI 8)",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby 2.5 applications on UBI 8. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/blob/master/2.5/README.md.",
"iconClass": "icon-ruby",
"tags": "builder,ruby",
"supports": "ruby:2.5,ruby",
"version": "2.5",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "DockerImage",
"name": "registry.access.redhat.com/ubi8/ruby-25:latest"
},
"referencePolicy": {
"type": "Local"
}
}
]
}
}

93
test/imagestreams/ruby-rhel-aarch64.json Normal file
View file

@ -0,0 +1,93 @@
{
"kind": "ImageStream",
"apiVersion": "v1",
"metadata": {
"name": "ruby",
"annotations": {
"openshift.io/display-name": "Ruby"
}
},
"spec": {
"tags": [
{
"name": "latest",
"annotations": {
"openshift.io/display-name": "Ruby (Latest)",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby applications on UBI. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/tree/master/2.7/README.md.\n\nWARNING: By selecting this tag, your application will automatically update to use the latest version of Ruby available on OpenShift, including major version updates.",
"iconClass": "icon-ruby",
"tags": "builder,ruby",
"supports": "ruby",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "ImageStreamTag",
"name": "2.7-ubi8"
},
"referencePolicy": {
"type": "Local"
}
},
{
"name": "2.7-ubi8",
"annotations": {
"openshift.io/display-name": "Ruby 2.7 (UBI 8)",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby 2.7 applications on UBI 8. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/blob/master/2.7/README.md.",
"iconClass": "icon-ruby",
"tags": "builder,ruby",
"supports": "ruby:2.7,ruby",
"version": "2.7",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "DockerImage",
"name": "registry.redhat.io/ubi8/ruby-27:latest"
},
"referencePolicy": {
"type": "Local"
}
},
{
"name": "2.6-ubi8",
"annotations": {
"openshift.io/display-name": "Ruby 2.6 (UBI 8)",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby 2.6 applications on UBI 8. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/blob/master/2.6/README.md.",
"iconClass": "icon-ruby",
"tags": "builder,ruby",
"supports": "ruby:2.6,ruby",
"version": "2.6",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "DockerImage",
"name": "registry.redhat.io/ubi8/ruby-26:latest"
},
"referencePolicy": {
"type": "Local"
}
},
{
"name": "2.5-ubi8",
"annotations": {
"openshift.io/display-name": "Ruby 2.5 (UBI 8)",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby 2.5 applications on UBI 8. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/blob/master/2.5/README.md.",
"iconClass": "icon-ruby",
"tags": "builder,ruby",
"supports": "ruby:2.5,ruby",
"version": "2.5",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "DockerImage",
"name": "registry.redhat.io/ubi8/ruby-25:latest"
},
"referencePolicy": {
"type": "Local"
}
}
]
}
}

193
test/imagestreams/ruby-rhel.json Normal file
View file

@ -0,0 +1,193 @@
{
"kind": "ImageStream",
"apiVersion": "v1",
"metadata": {
"name": "ruby",
"annotations": {
"openshift.io/display-name": "Ruby"
}
},
"spec": {
"tags": [
{
"name": "latest",
"annotations": {
"openshift.io/display-name": "Ruby (Latest)",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby applications on UBI. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/tree/master/2.7/README.md.\n\nWARNING: By selecting this tag, your application will automatically update to use the latest version of Ruby available on OpenShift, including major version updates.",
"iconClass": "icon-ruby",
"tags": "builder,ruby",
"supports": "ruby",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "ImageStreamTag",
"name": "2.7-ubi8"
},
"referencePolicy": {
"type": "Local"
}
},
{
"name": "2.7-ubi8",
"annotations": {
"openshift.io/display-name": "Ruby 2.7 (UBI 8)",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby 2.7 applications on UBI 8. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/blob/master/2.7/README.md.",
"iconClass": "icon-ruby",
"tags": "builder,ruby",
"supports": "ruby:2.7,ruby",
"version": "2.7",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "DockerImage",
"name": "registry.redhat.io/ubi8/ruby-27:latest"
},
"referencePolicy": {
"type": "Local"
}
},
{
"name": "3.0-ubi7",
"annotations": {
"openshift.io/display-name": "Ruby 3.0 (UBI 7)",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby 3.0 applications on UBI 7. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/blob/master/3.0/README.md.",
"iconClass": "icon-ruby",
"tags": "builder,ruby",
"supports": "ruby:3.0,ruby",
"version": "3.0",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "DockerImage",
"name": "registry.redhat.io/ubi7/ruby-30:latest"
},
"referencePolicy": {
"type": "Local"
}
},
{
"name": "2.7-ubi7",
"annotations": {
"openshift.io/display-name": "Ruby 2.7 (UBI 7)",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby 2.7 applications on UBI 7. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/blob/master/2.7/README.md.",
"iconClass": "icon-ruby",
"tags": "builder,ruby",
"supports": "ruby:2.7,ruby",
"version": "2.7",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "DockerImage",
"name": "registry.redhat.io/ubi7/ruby-27:latest"
},
"referencePolicy": {
"type": "Local"
}
},
{
"name": "2.7",
"annotations": {
"openshift.io/display-name": "Ruby 2.7",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby 2.7 applications on RHEL 7. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/blob/master/2.7/README.md.",
"iconClass": "icon-ruby",
"tags": "builder,ruby,hidden",
"supports": "ruby:2.7,ruby",
"version": "2.7",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "DockerImage",
"name": "registry.redhat.io/rhscl/ruby-27-rhel7:latest"
},
"referencePolicy": {
"type": "Local"
}
},
{
"name": "2.6-ubi8",
"annotations": {
"openshift.io/display-name": "Ruby 2.6 (UBI 8)",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby 2.6 applications on UBI 8. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/blob/master/2.6/README.md.",
"iconClass": "icon-ruby",
"tags": "builder,ruby",
"supports": "ruby:2.6,ruby",
"version": "2.6",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "DockerImage",
"name": "registry.redhat.io/ubi8/ruby-26:latest"
},
"referencePolicy": {
"type": "Local"
}
},
{
"name": "2.6-ubi7",
"annotations": {
"openshift.io/display-name": "Ruby 2.6 (UBI 7)",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby 2.6 applications on UBI 7. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/blob/master/2.6/README.md.",
"iconClass": "icon-ruby",
"tags": "builder,ruby",
"supports": "ruby:2.6,ruby",
"version": "2.6",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "DockerImage",
"name": "registry.redhat.io/ubi7/ruby-26:latest"
},
"referencePolicy": {
"type": "Local"
}
},
{
"name": "2.6",
"annotations": {
"openshift.io/display-name": "Ruby 2.6",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby 2.6 applications on RHEL 7. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/blob/master/2.6/README.md.",
"iconClass": "icon-ruby",
"tags": "builder,ruby,hidden",
"supports": "ruby:2.6,ruby",
"version": "2.6",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "DockerImage",
"name": "registry.redhat.io/rhscl/ruby-26-rhel7:latest"
},
"referencePolicy": {
"type": "Local"
}
},
{
"name": "2.5-ubi8",
"annotations": {
"openshift.io/display-name": "Ruby 2.5 (UBI 8)",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"description": "Build and run Ruby 2.5 applications on UBI 8. For more information about using this builder image, including OpenShift considerations, see https://github.com/sclorg/s2i-ruby-container/blob/master/2.5/README.md.",
"iconClass": "icon-ruby",
"tags": "builder,ruby",
"supports": "ruby:2.5,ruby",
"version": "2.5",
"sampleRepo": "https://github.com/sclorg/ruby-ex.git"
},
"from": {
"kind": "DockerImage",
"name": "registry.redhat.io/ubi8/ruby-25:latest"
},
"referencePolicy": {
"type": "Local"
}
}
]
}
}

4
test/puma-test-app/Gemfile Executable file
View file

@ -0,0 +1,4 @@
source 'https://rubygems.org'
gem 'sinatra'
gem 'puma'

21
test/puma-test-app/Gemfile.lock Normal file
View file

@ -0,0 +1,21 @@
GEM
remote: https://rubygems.org/
specs:
mustermann (1.0.1)
puma (3.11.2)
rack (2.0.4)
rack-protection (2.0.0)
rack
sinatra (2.0.0)
mustermann (~> 1.0)
rack (~> 2.0)
rack-protection (= 2.0.0)
tilt (~> 2.0)
tilt (2.0.8)
PLATFORMS
ruby
DEPENDENCIES
puma
sinatra

5
test/puma-test-app/app.rb Executable file
View file

@ -0,0 +1,5 @@
require 'sinatra'
get '/' do
'Hello world!'
end

2
test/puma-test-app/config.ru Executable file
View file

@ -0,0 +1,2 @@
require './app'
run Sinatra::Application

3
test/rack-test-app/Gemfile Executable file
View file

@ -0,0 +1,3 @@
source 'https://rubygems.org'
gem 'sinatra'

19
test/rack-test-app/Gemfile.lock Normal file
View file

@ -0,0 +1,19 @@
GEM
remote: https://rubygems.org/
specs:
mustermann (1.0.1)
rack (2.0.4)
rack-protection (2.0.0)
rack
sinatra (2.0.0)
mustermann (~> 1.0)
rack (~> 2.0)
rack-protection (= 2.0.0)
tilt (~> 2.0)
tilt (2.0.8)
PLATFORMS
ruby
DEPENDENCIES
sinatra

5
test/rack-test-app/app.rb Executable file
View file

@ -0,0 +1,5 @@
require 'sinatra'
get '/' do
'Hello world!'
end

2
test/rack-test-app/config.ru Executable file
View file

@ -0,0 +1,2 @@
require './app'
run Sinatra::Application

269
test/run Executable file
View file

@ -0,0 +1,269 @@
#!/bin/bash -x
#
# The 'run' performs a simple test that verifies that S2I image.
# The main focus here is to excersise the S2I scripts.
#
# IMAGE_NAME specifies a name of the candidate image used for testing.
# The image has to be available before this script is executed.
#
IMAGE_NAME=${IMAGE_NAME-quay.io/centos7/ruby-27-centos7-candidate}
declare -a WEB_SERVERS=(db puma rack)
#declare -a WEB_SERVERS=(db)
# TODO: Make command compatible for Mac users
test_dir="$(readlink -zf $(dirname "${BASH_SOURCE[0]}"))"
image_dir=$(readlink -zf ${test_dir}/..)
test_short_summary=''
TESTSUITE_RESULT=0
TEST_LIST="\
test_docker_run_usage
test_application
test_connection
test_scl_variables_in_dockerfile
test_scl_usage
test_npm_functionality
"
source "${test_dir}/test-lib.sh"
# Read exposed port from image meta data
test_port="$(docker inspect --format='{{range $key, $value := .Config.ExposedPorts }}{{$key}}{{end}}' ${IMAGE_NAME} | sed 's/\/.*//')"
info() {
echo -e "\n\e[1m[INFO] $@...\e[0m\n"
}
image_exists() {
docker inspect $1 &>/dev/null
}
container_exists() {
image_exists $(cat $cid_file)
}
container_ip() {
docker inspect --format="{{ .NetworkSettings.IPAddress }}" $(cat $cid_file)
}
run_s2i_build() {
ct_s2i_build_as_df file://${test_dir}/${1}-test-app ${IMAGE_NAME} ${IMAGE_NAME}-testapp ${s2i_args} $(ct_build_s2i_npm_variables)
}
run_test_application() {
docker run --user=100001 --rm --cidfile=${cid_file} ${IMAGE_NAME}-testapp
}
cleanup() {
local server="$1"
info "Cleaning up the test application image $1"
if [ -f $cid_file ]; then
if container_exists; then
docker stop $(cat $cid_file)
fi
fi
if image_exists ${IMAGE_NAME}-testapp; then
docker rmi -f ${IMAGE_NAME}-testapp
fi
if [ ! -z "${server}" ]; then
rm -rf ${test_dir}/${server}-test-app/.git
fi
if [[ "${server}" == "db" ]]; then
rm -rf ${test_dir}/db-test-app
fi
}
check_result() {
local result="$1"
if [[ "$result" != "0" ]]; then
TESTCASE_RESULT=1
fi
return $result
}
wait_for_cid() {
local max_attempts=10
local sleep_time=1
local attempt=1
local result=1
info "Waiting for application container to start"
while [ $attempt -le $max_attempts ]; do
[ -f $cid_file ] && [ -s $cid_file ] && break
attempt=$(( $attempt + 1 ))
sleep $sleep_time
done
if [ $attempt -gt $max_attempts ]; then
return 1
fi
}
test_s2i_usage() {
info "Testing 's2i usage'"
ct_s2i_usage ${IMAGE_NAME} ${s2i_args} &>/dev/null
check_result "$?"
}
test_docker_run_usage() {
info "Testing 'docker run' usage"
docker run ${IMAGE_NAME} &>/dev/null
check_result "$?"
}
test_connection() {
info "Testing the HTTP connection (http://$(container_ip):${test_port})"
local max_attempts=10
local sleep_time=1
local attempt=1
local result=1
while [ $attempt -le $max_attempts ]; do
response_code=$(curl -s -w %{http_code} -o /dev/null http://$(container_ip):${test_port}/)
status=$?
if [ $status -eq 0 ]; then
if [ $response_code -eq 200 ]; then
echo "SUCCESS, container returned 200"
result=0
fi
break
fi
attempt=$(( $attempt + 1 ))
sleep $sleep_time
done
return $result
}
scl_usage() {
local run_cmd="$1"
local expected="$2"
info "Testing the image SCL enable"
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 $(cat ${cid_file}) /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 $(cat ${cid_file}) /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
return 0
}
function test_scl_usage() {
scl_usage "ruby --version" "ruby ${RUBY_VERSION}."
check_result "$?"
}
function test_npm_functionality() {
info "Testing npm availibility"
ct_npm_works
check_result "$?"
}
function handle_test_case_result() {
local output_format
output_format="%s %s $1\n"
shift
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 "${output_format}" "${test_short_summary}" "${test_msg}" $@
}
function run_all_tests() {
local APP_NAME="$1"
for test_case in $TEST_SET; do
info "Running test $test_case ... "
TESTCASE_RESULT=0
$test_case
check_result $?
local test_msg
handle_test_case_result "for '%s' %s" "${APP_NAME}" "$test_case"
[ -n "${FAIL_QUICKLY:-}" ] && {
cleanup "${APP_NAME}"
return 1
}
done;
cleanup "${APP_NAME}"
}
function test_application() {
# Verify that the HTTP connection can be established to test application container
run_test_application &
# Wait for the container to write it's CID file
wait_for_cid
check_result $?
}
function test_scl_variables_in_dockerfile() {
if [ "$OS" == "rhel7" ] || [ "$OS" == "centos7" ]; then
# autocleanup only enabled here as only the following tests so far use it
CID_FILE_DIR=$(mktemp -d)
ct_enable_cleanup
info "Testing variable presence during \`docker exec\`"
ct_check_exec_env_vars
check_result $?
info "Checking if all scl variables are defined in Dockerfile"
ct_check_scl_enable_vars
check_result $?
fi
}
function test_from_dockerfile() {
dockerfile="Dockerfile${1:-}"
TESTCASE_RESULT=0
info "Check building using a $dockerfile"
ct_test_app_dockerfile $test_dir/examples/from-dockerfile/$dockerfile 'https://github.com/sclorg/rails-ex.git' 'Welcome to your Rails application on OpenShift' app-src
check_result $?
handle_test_case_result "test_from_dockerfile for %s" "${dockerfile}"
}
pushd ${test_dir}
if [ -d db-test-app ]; then
rm -rf db-test-app
fi
git clone git://github.com/openshift/ruby-hello-world db-test-app
popd
for server in ${WEB_SERVERS[@]}; do
cid_file=$(mktemp -u --suffix=.cid)
# Since we built the candidate image locally, we don't want S2I attempt to pull
# it from Docker hub
s2i_args="--pull-policy=never"
TESTCASE_RESULT=0
run_s2i_build "${server}"
check_result $?
handle_test_case_result "build of '%s' app" "${server}"
TEST_SET=${TESTS:-$TEST_LIST} run_all_tests "$server"
cleanup "${server}"
done
test_from_dockerfile
test_from_dockerfile ".s2i"
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

2
test/run-conu Executable file
View file

@ -0,0 +1,2 @@
#!/bin/bash
exec pytest -vv -k test_s2i

1
test/run-openshift Symbolic link
View file

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

37
test/run-openshift-remote-cluster Executable file
View file

@ -0,0 +1,37 @@
#!/bin/bash
#
# Test the Ruby S2I 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 Ruby runtime in format of X.Y
# OS specifies RHEL version (e.g. OS=rhel7)
#
THISDIR=$(dirname ${BASH_SOURCE[0]})
source ${THISDIR}/test-lib-ruby.sh
source ${THISDIR}/test-lib-remote-openshift.sh
set -eo nounset
ct_os_set_ocp4
trap ct_os_cleanup EXIT SIGINT
ct_os_check_compulsory_vars
oc status || false "It looks like oc is not properly logged in."
# For testing on OpenShift 4 we use internal registry
export CT_EXTERNAL_REGISTRY=true
test_ruby_integration "${IMAGE_NAME}"
# Check the imagestream
test_ruby_imagestream
OS_TESTSUITE_RESULT=0
# vim: set tabstop=2:shiftwidth=2:expandtab:

1
test/test-lib-openshift.sh Symbolic link
View file

@ -0,0 +1 @@
../common/test-lib-openshift.sh

116
test/test-lib-remote-openshift.sh Normal file
View file

@ -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
}

36
test/test-lib-ruby.sh Normal file
View file

@ -0,0 +1,36 @@
#!/bin/bash
#
# Functions for tests for the Ruby S2I 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
function test_ruby_integration() {
local image_name=$1
ct_os_test_s2i_app "${image_name}" \
"https://github.com/sclorg/s2i-ruby-container.git" \
"${VERSION}/test/puma-test-app" \
".*"
}
# Check the imagestream
function test_ruby_imagestream() {
case ${OS} in
rhel7|centos7) ;;
*) echo "Imagestream testing not supported for $OS environment." ; return 0 ;;
esac
ct_os_test_image_stream_s2i "${THISDIR}/imagestreams/ruby-${OS%[0-9]*}.json" "${IMAGE_NAME}" \
"https://github.com/sclorg/s2i-ruby-container.git" \
"${VERSION}/test/puma-test-app" \
".*"
}
# vim: set tabstop=2:shiftwidth=2:expandtab:

1072
test/test-lib.sh Normal file
View file

File diff suppressed because it is too large Load diff

84
test/test_s2i.py Normal file
View file

@ -0,0 +1,84 @@
#!/usr/bin/python3
import logging
import os
import time
from conu import DockerBackend, S2IDockerImage, Probe, DockerRunBuilder
import pytest
image_name = os.environ.get("IMAGE_NAME", "ruby").split(":")[0]
image_tag = os.environ.get("IMAGE_NAME", "ruby").split(":")[1]
test_dir = os.path.abspath(os.path.dirname(__file__))
puma_app_path = os.path.join(test_dir, "puma-test-app")
rack_app_path = os.path.join(test_dir, "rack-test-app")
app_paths = [
puma_app_path,
rack_app_path
]
backend = DockerBackend(logging_level=logging.DEBUG)
@pytest.fixture(scope="module", params=app_paths)
def app(request):
i = S2IDockerImage(image_name, tag=image_tag)
app_name = os.path.basename(request.param)
app = i.extend(request.param, app_name)
yield app
pass
app.rmi()
class TestSuite:
def test_s2i_apps(self, app):
c = app.run_via_binary()
try:
c.wait_for_port(8080)
assert c.is_port_open(8080)
response = c.http_request("/", port="8080")
assert response.ok
output = c.execute(["bash", "-c", "ruby --version"])[0]
expected = "ruby %s." % os.environ["VERSION"]
assert expected in output.decode("utf-8")
finally:
c.stop()
c.wait()
# debugging
print(list(c.logs()))
c.delete()
def test_invoking_container(self):
image = backend.ImageClass(image_name, tag=image_tag)
c = image.run_via_binary(DockerRunBuilder(command=["bash", "-c", "ruby --version"]))
try:
c.wait()
logs = list(c.logs())[0].decode("utf-8")
finally:
c.stop()
c.wait()
c.delete()
assert "ruby " in logs
if os.environ.get("VERSION", None):
assert os.environ["VERSION"] in logs
def test_usage(self):
i = S2IDockerImage(image_name, tag=image_tag)
c = i.run_via_binary()
def logs_received():
return len(list(c.logs())) > 0
try:
c.wait()
# even after waiting there is still a race in journal logging driver
Probe(timeout=10, pause=0.05, count=20, fnc=logs_received).run()
logs = [x.decode("utf-8") for x in c.logs()]
logs = "\n".join(logs).strip()
usage = i.usage()
# FIXME: workaround: `docker logs` can't handle logs like these: '\n\n\n'
assert logs.replace("\n", "") == usage.replace("\n", "")
finally:
c.delete()