diff --git a/.gitignore b/.gitignore
deleted file mode 100644
index e69de29..0000000
diff --git a/2.5 b/2.5
deleted file mode 120000
index 945c9b4..0000000
--- a/2.5
+++ /dev/null
@@ -1 +0,0 @@
-.
\ No newline at end of file
diff --git a/Dockerfile b/Dockerfile
deleted file mode 100644
index c367bab..0000000
--- a/Dockerfile
+++ /dev/null
@@ -1,51 +0,0 @@
-FROM registry.fedoraproject.org/f30/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.5 \
-    RUBY_SHORT_VER=25 \
-    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=2.4/test/puma-test-app/ registry.fedoraproject.org/$FGC/ruby ruby-sample-app" \
-      maintainer="SoftwareCollections.org <sclorg@redhat.com>"
-
-# Install required packages
-RUN INSTALL_PKGS="python2 ruby ruby-devel rubygem-bundler rubygem-rake rubygems-devel redhat-rpm-config" && \
-    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
diff --git a/Dockerfile.fedora b/Dockerfile.fedora
deleted file mode 120000
index 1d1fe94..0000000
--- a/Dockerfile.fedora
+++ /dev/null
@@ -1 +0,0 @@
-Dockerfile
\ No newline at end of file
diff --git a/README.md b/README.md
deleted file mode 100644
index 94bddf3..0000000
--- a/README.md
+++ /dev/null
@@ -1,146 +0,0 @@
-Ruby 2.5 container image
-=================
-
-This container image includes Ruby 2.5 as a [S2I](https://github.com/openshift/source-to-image) base image for your Ruby 2.5 applications.
-Users can choose between RHEL and CentOS based builder images.
-The RHEL image is available in the [Red Hat Container Catalog](https://access.redhat.com/containers/#/registry.access.redhat.com/rhscl/ruby-25-rhel7)
-as registry.access.redhat.com/rhscl/ruby-25-rhel7.
-The CentOS image is then available on [Docker Hub](https://hub.docker.com/r/centos/ruby-25-centos7/)
-as centos/ruby-25-centos7.
-The resulting image can be run using [Docker](http://docker.io).
-
-Description
------------
-
-Ruby 2.5 available as container is a base platform for
-building and running various Ruby 2.5 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
----------------------
-To build a simple [ruby-sample-app](https://github.com/sclorg/s2i-ruby-container/tree/master/2.5/test/puma-test-app) application
-using standalone [S2I](https://github.com/openshift/source-to-image) and then run the
-resulting image with [Docker](http://docker.io) execute:
-
-*  **For RHEL based image**
-    ```
-    $ s2i build https://github.com/sclorg/s2i-ruby-container.git --context-dir=2.5/test/puma-test-app/ rhscl/ruby-25-rhel7 ruby-sample-app
-    $ docker run -p 8080:8080 ruby-sample-app
-    ```
-
-*  **For CentOS based image**
-    ```
-    $ s2i build https://github.com/sclorg/s2i-ruby-container.git --context-dir=2.5/test/puma-test-app/ centos/ruby-25-centos7 ruby-sample-app
-    $ docker run -p 8080:8080 ruby-sample-app
-    ```
-
-**Accessing the application:**
-```
-$ curl 127.0.0.1:8080
-```
-
-Environment variables
----------------------
-
-To set these environment variables, you can place them as a key value pair into a `.sti/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 [Docker](http://docker.io) `-e` run flag:
-    ```
-    $ docker 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 [Docker](http://docker.io) -e run flag:
-    ```
-    $ docker run -e RACK_ENV=development -p 8080:8080 sinatra-app
-    ```
-
-To change your source code in running container, use Docker's [exec](http://docker.io) command:
-```
-docker exec -it <CONTAINER_ID> /bin/bash
-```
-
-After you [Docker exec](http://docker.io) 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 [Docker](http://docker.io) run command:
-```
-$ docker 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:
-```
-$ docker 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 Python environment Dockerfiles.
-Dockerfile for CentOS is called Dockerfile, Dockerfile for RHEL is called Dockerfile.rhel7.
diff --git a/dead.package b/dead.package
new file mode 100644
index 0000000..7290702
--- /dev/null
+++ b/dead.package
@@ -0,0 +1 @@
+container sources not used for building fedora containers anymore
diff --git a/help.md b/help.md
deleted file mode 120000
index 42061c0..0000000
--- a/help.md
+++ /dev/null
@@ -1 +0,0 @@
-README.md
\ No newline at end of file
diff --git a/root/help.1 b/root/help.1
deleted file mode 100644
index e5c88b5..0000000
--- a/root/help.1
+++ /dev/null
@@ -1,250 +0,0 @@
-.TH Ruby 2.5 container image
-.PP
-This container image includes Ruby 2.5 as a S2I
-\[la]https://github.com/openshift/source-to-image\[ra] base image for your Ruby 2.5 applications.
-Users can choose between RHEL and CentOS based builder images.
-The RHEL image is available in the Red Hat Container Catalog
-\[la]https://access.redhat.com/containers/#/registry.access.redhat.com/rhscl/ruby-25-rhel7\[ra]
-as registry.access.redhat.com/rhscl/ruby\-25\-rhel7.
-The CentOS image is then available on Docker Hub
-\[la]https://hub.docker.com/r/centos/ruby-25-centos7/\[ra]
-as centos/ruby\-25\-centos7.
-The resulting image can be run using Docker
-\[la]http://docker.io\[ra]\&.
-
-.SH Description
-.PP
-Ruby 2.5 available as container is a base platform for
-building and running various Ruby 2.5 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.
-
-.PP
-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.
-
-.SH Usage
-.PP
-To build a simple ruby\-sample\-app
-\[la]https://github.com/sclorg/s2i-ruby-container/tree/master/2.5/test/puma-test-app\[ra] application
-using standalone S2I
-\[la]https://github.com/openshift/source-to-image\[ra] and then run the
-resulting image with Docker
-\[la]http://docker.io\[ra] execute:
-.IP \(bu 2
-
-.PP
-\fBFor RHEL based image\fP
-.PP
-.RS
-
-.nf
-$ s2i build https://github.com/sclorg/s2i\-ruby\-container.git \-\-context\-dir=2.5/test/puma\-test\-app/ rhscl/ruby\-25\-rhel7 ruby\-sample\-app
-$ docker run \-p 8080:8080 ruby\-sample\-app
-
-.fi
-.RE
-.IP \(bu 2
-
-.PP
-\fBFor CentOS based image\fP
-.PP
-.RS
-
-.nf
-$ s2i build https://github.com/sclorg/s2i\-ruby\-container.git \-\-context\-dir=2.5/test/puma\-test\-app/ centos/ruby\-25\-centos7 ruby\-sample\-app
-$ docker run \-p 8080:8080 ruby\-sample\-app
-
-.fi
-.RE
-
-.PP
-\fBAccessing the application:\fP
-
-.PP
-.RS
-
-.nf
-$ curl 127.0.0.1:8080
-
-.fi
-.RE
-
-.SH Environment variables
-.PP
-To set these environment variables, you can place them as a key value pair into a \fB\fC\&.sti/environment\fR
-file inside your source code repository.
-.IP \(bu 2
-
-.PP
-\fBRACK\_ENV\fP
-.PP
-This variable specifies the environment where the Ruby application will be deployed (unless overwritten) \- \fB\fCproduction\fR, \fB\fCdevelopment\fR, \fB\fCtest\fR\&.
-Each level has different behaviors in terms of logging verbosity, error pages, ruby gem installation, etc.
-
-.PP
-\fBNote\fP: Application assets will be compiled only if the \fB\fCRACK\_ENV\fR is set to \fB\fCproduction\fR
-.IP \(bu 2
-
-.PP
-\fBDISABLE\_ASSET\_COMPILATION\fP
-.PP
-This variable set to \fB\fCtrue\fR indicates that the asset compilation process will be skipped. Since this only takes place
-when the application is run in the \fB\fCproduction\fR environment, it should only be used when assets are already compiled.
-.IP \(bu 2
-
-.PP
-\fBPUMA\_MIN\_THREADS\fP, \fBPUMA\_MAX\_THREADS\fP
-.PP
-These variables indicate the minimum and maximum threads that will be available in Puma
-\[la]https://github.com/puma/puma\[ra]\&'s thread pool.
-.IP \(bu 2
-
-.PP
-\fBPUMA\_WORKERS\fP
-.PP
-This variable indicate the number of worker processes that will be launched. See documentation on Puma's clustered mode
-\[la]https://github.com/puma/puma#clustered-mode\[ra]\&.
-.IP \(bu 2
-
-.PP
-\fBRUBYGEM\_MIRROR\fP
-.PP
-Set this variable to use a custom RubyGems mirror URL to download required gem packages during build process.
-
-.SH Hot deploy
-.PP
-In order to dynamically pick up changes made in your application source code, you need to make following steps:
-.IP \(bu 2
-
-.PP
-\fBFor Ruby on Rails applications\fP
-.PP
-Run the built Rails image with the \fB\fCRAILS\_ENV=development\fR environment variable passed to the Docker
-\[la]http://docker.io\[ra] \fB\fC\-e\fR run flag:
-
-.PP
-.RS
-
-.nf
-$ docker run \-e RAILS\_ENV=development \-p 8080:8080 rails\-app
-
-.fi
-.RE
-.IP \(bu 2
-
-.PP
-\fBFor other types of Ruby applications (Sinatra, Padrino, etc.)\fP
-.PP
-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:
-.IP \(bu 2
-Shotgun
-\[la]https://github.com/rtomayko/shotgun\[ra]
-.IP \(bu 2
-Rerun
-\[la]https://github.com/alexch/rerun\[ra]
-.IP \(bu 2
-Rack\-livereload
-\[la]https://github.com/johnbintz/rack-livereload\[ra]
-
-.PP
-Please note that in order to be able to run your application in development mode, you need to modify the S2I run script
-\[la]https://github.com/openshift/source-to-image#anatomy-of-a-builder-image\[ra], so the web server is launched by the chosen gem, which checks for changes in the source code.
-
-.PP
-After you built your application image with your version of S2I run script
-\[la]https://github.com/openshift/source-to-image#anatomy-of-a-builder-image\[ra], run the image with the RACK\_ENV=development environment variable passed to the Docker
-\[la]http://docker.io\[ra] \-e run flag:
-
-.PP
-.RS
-
-.nf
-$ docker run \-e RACK\_ENV=development \-p 8080:8080 sinatra\-app
-
-.fi
-.RE
-
-.PP
-To change your source code in running container, use Docker's exec
-\[la]http://docker.io\[ra] command:
-
-.PP
-.RS
-
-.nf
-docker exec \-it <CONTAINER\_ID> /bin/bash
-
-.fi
-.RE
-
-.PP
-After you Docker exec
-\[la]http://docker.io\[ra] into the running container, your current
-directory is set to \fB\fC/opt/app\-root/src\fR, where the source code is located.
-
-.SH Performance tuning
-.PP
-You can tune the number of threads per worker using the
-\fB\fCPUMA\_MIN\_THREADS\fR and \fB\fCPUMA\_MAX\_THREADS\fR 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
-\[la]https://github.com/puma/puma\[ra]\&'s documentation. This is determined using
-the cgroup cpusets
-\[la]https://www.kernel.org/doc/Documentation/cgroup-v1/cpusets.txt\[ra]
-subsystem. You can specify the cores that the container is allowed to use by passing
-the \fB\fC\-\-cpuset\-cpus\fR parameter to the Docker
-\[la]http://docker.io\[ra] run command:
-
-.PP
-.RS
-
-.nf
-$ docker run \-e PUMA\_MAX\_THREADS=32 \-\-cpuset\-cpus='0\-2,3,5' \-p 8080:8080 sinatra\-app
-
-.fi
-.RE
-
-.PP
-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:
-
-.PP
-.RS
-
-.nf
-50 + 15 * WORKERS + 0.125 * WORKERS * PUMA\_MAX\_THREADS
-
-.fi
-.RE
-
-.PP
-You can specify a memory limit using the \fB\fC\-\-memory\fR flag:
-
-.PP
-.RS
-
-.nf
-$ docker run \-e PUMA\_MAX\_THREADS=32 \-\-memory=300m \-p 8080:8080 sinatra\-app
-
-.fi
-.RE
-
-.PP
-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 \fB\fCPUMA\_WORKERS\fR\&.
-
-.SH See also
-.PP
-Dockerfile and other sources are available on 
-\[la]https://github.com/sclorg/s2i-ruby-container\[ra]\&.
-In that repository you also can find another versions of Python environment Dockerfiles.
-Dockerfile for CentOS is called Dockerfile, Dockerfile for RHEL is called Dockerfile.rhel7.
diff --git a/root/opt/app-root/.gemrc b/root/opt/app-root/.gemrc
deleted file mode 100644
index 2422bea..0000000
--- a/root/opt/app-root/.gemrc
+++ /dev/null
@@ -1,9 +0,0 @@
----
-install: --no-document
-update: --no-document
-:benchmark: false
-:update_sources: true
-:bulk_threshold: 1000
-:backtrace: true
-:sources:
-- https://rubygems.org/
diff --git a/root/opt/app-root/etc/puma.cfg b/root/opt/app-root/etc/puma.cfg
deleted file mode 100644
index a52d26d..0000000
--- a/root/opt/app-root/etc/puma.cfg
+++ /dev/null
@@ -1,50 +0,0 @@
-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'
diff --git a/root/opt/app-root/etc/scl_enable b/root/opt/app-root/etc/scl_enable
deleted file mode 100644
index 826d94c..0000000
--- a/root/opt/app-root/etc/scl_enable
+++ /dev/null
@@ -1,6 +0,0 @@
-# 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 rh-ruby25 $NODEJS_SCL
diff --git a/s2i/bin/assemble b/s2i/bin/assemble
deleted file mode 100755
index f3a4b8d..0000000
--- a/s2i/bin/assemble
+++ /dev/null
@@ -1,71 +0,0 @@
-#!/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/* ./
-
-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 ./
-
-# Make the ./tmp folder world writeable as Rails or other frameworks might use
-# it to store temporary data (uploads/cache/sessions/etcd).
-# The ./db folder has to be writeable as well because when Rails complete the
-# migration it writes the schema version into ./db/schema.db
-set +e
-[[ -d ./tmp ]] && chgrp -R 0 ./tmp && chmod -R g+rw ./tmp
-[[ -d ./db ]] && chgrp -R 0 ./db && chmod -R g+rw ./db
-set -e
diff --git a/s2i/bin/run b/s2i/bin/run
deleted file mode 100755
index 1614ec3..0000000
--- a/s2i/bin/run
+++ /dev/null
@@ -1,39 +0,0 @@
-#!/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
diff --git a/s2i/bin/usage b/s2i/bin/usage
deleted file mode 100755
index c04792f..0000000
--- a/s2i/bin/usage
+++ /dev/null
@@ -1,18 +0,0 @@
-#!/bin/sh
-
-DISTRO=`cat /etc/*-release | grep ^ID= | grep -Po '".*?"' | tr -d '"'`
-NAMESPACE=centos
-[[ $DISTRO =~ rhel* ]] && NAMESPACE=rhscl
-
-cat <<EOF
-This is a S2I ruby-${RUBY_VERSION} ${DISTRO} base image:
-To use it, install S2I: https://github.com/openshift/source-to-image
-
-Sample invocation:
-
-s2i build https://github.com/sclorg/s2i-ruby-container.git --context-dir=${RUBY_VERSION}/test/puma-test-app/ ${NAMESPACE}/ruby-${RUBY_SCL_NAME_VERSION}-${DISTRO}7 ruby-sample-app
-
-
-You can then run the resulting image via:
-docker run -p 8080:8080 ruby-sample-app
-EOF
diff --git a/test/puma-test-app/Gemfile b/test/puma-test-app/Gemfile
deleted file mode 100755
index a98e5e1..0000000
--- a/test/puma-test-app/Gemfile
+++ /dev/null
@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'sinatra'
-gem 'puma'
diff --git a/test/puma-test-app/Gemfile.lock b/test/puma-test-app/Gemfile.lock
deleted file mode 100644
index 2b2190d..0000000
--- a/test/puma-test-app/Gemfile.lock
+++ /dev/null
@@ -1,21 +0,0 @@
-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
diff --git a/test/puma-test-app/app.rb b/test/puma-test-app/app.rb
deleted file mode 100755
index cd7e87d..0000000
--- a/test/puma-test-app/app.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-require 'sinatra'
-
-get '/' do
-  'Hello world!'
-end
diff --git a/test/puma-test-app/config.ru b/test/puma-test-app/config.ru
deleted file mode 100755
index 76a6edf..0000000
--- a/test/puma-test-app/config.ru
+++ /dev/null
@@ -1,2 +0,0 @@
-require './app'
-run Sinatra::Application
diff --git a/test/rack-test-app/Gemfile b/test/rack-test-app/Gemfile
deleted file mode 100755
index c10abd7..0000000
--- a/test/rack-test-app/Gemfile
+++ /dev/null
@@ -1,3 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'sinatra'
diff --git a/test/rack-test-app/Gemfile.lock b/test/rack-test-app/Gemfile.lock
deleted file mode 100644
index 1569406..0000000
--- a/test/rack-test-app/Gemfile.lock
+++ /dev/null
@@ -1,19 +0,0 @@
-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
diff --git a/test/rack-test-app/app.rb b/test/rack-test-app/app.rb
deleted file mode 100755
index cd7e87d..0000000
--- a/test/rack-test-app/app.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-require 'sinatra'
-
-get '/' do
-  'Hello world!'
-end
diff --git a/test/rack-test-app/config.ru b/test/rack-test-app/config.ru
deleted file mode 100755
index 76a6edf..0000000
--- a/test/rack-test-app/config.ru
+++ /dev/null
@@ -1,2 +0,0 @@
-require './app'
-run Sinatra::Application
diff --git a/test/run b/test/run
deleted file mode 100755
index 9a44b81..0000000
--- a/test/run
+++ /dev/null
@@ -1,186 +0,0 @@
-#!/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-centos/ruby-25-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}/..)
-
-source "${test_dir}/test-lib.sh"
-
-# Read exposed port from image meta data
-test_port="$(docker inspect --format='{{range $key, $value := .ContainerConfig.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}
-}
-
-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
-    info "TEST FAILED (${result})"
-    cleanup
-    exit $result
-  fi
-}
-
-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
-}
-
-test_s2i_usage() {
-  info "Testing 's2i usage'"
-  ct_s2i_usage ${IMAGE_NAME} ${s2i_args} &>/dev/null
-}
-
-test_docker_run_usage() {
-  info "Testing 'docker run' usage"
-  docker run ${IMAGE_NAME} &>/dev/null
-}
-
-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
-        result=0
-      fi
-      break
-    fi
-    attempt=$(( $attempt + 1 ))
-    sleep $sleep_time
-  done
-  return $result
-}
-
-test_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
-}
-
-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"
-
-  run_s2i_build ${server}
-  check_result $?
-
-  # Verify the 'usage' script is working properly when running the base image with 's2i usage ...'
-  test_s2i_usage
-  check_result $?
-
-  # Verify the 'usage' script is working properly when running the base image with 'docker run ...'
-  test_docker_run_usage
-  check_result $?
-
-  # 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
-
-  test_connection
-  check_result $?
-
-  test_scl_usage "ruby --version" "ruby ${RUBY_VERSION}."
-  check_result $?
-
-  info "All tests for the ${server}-test-app finished successfully."
-  cleanup ${server}
-done
-
-info "Testing npm availibility"
-ct_npm_works
-check_result $?
-
-info "All tests finished successfully."
diff --git a/test/test-lib.sh b/test/test-lib.sh
deleted file mode 100644
index c381d45..0000000
--- a/test/test-lib.sh
+++ /dev/null
@@ -1,503 +0,0 @@
-#
-# Test a container image.
-#
-# Always use sourced from a specific container testfile 
-#
-# reguires definition of CID_FILE_DIR
-# CID_FILE_DIR=$(mktemp --suffix=<container>_test_cidfiles -d)
-# reguires definition of TEST_LIST 
-# TEST_LIST="\
-# ctest_container_creation
-# ctest_doc_content"
-
-# Container CI tests
-# abbreviated as "ct"
-
-# may be redefined in the specific container testfile
-EXPECTED_EXIT_CODE=0
-
-# ct_cleanup
-# --------------------
-# Cleans up containers used during tests. Stops and removes all containers
-# referenced by cid_files in CID_FILE_DIR. Dumps logs if a container exited
-# unexpectedly. Removes the cid_files and CID_FILE_DIR as well.
-# Uses: $CID_FILE_DIR - path to directory containing cid_files
-# Uses: $EXPECTED_EXIT_CODE - expected container exit code
-function ct_cleanup() {
-  for cid_file in $CID_FILE_DIR/* ; do
-    local container=$(cat $cid_file)
-
-    : "Stopping and removing container $container..."
-    docker stop $container
-    exit_status=$(docker inspect -f '{{.State.ExitCode}}' $container)
-    if [ "$exit_status" != "$EXPECTED_EXIT_CODE" ]; then
-      : "Dumping logs for $container"
-      docker logs $container
-    fi
-    docker rm -v $container
-    rm $cid_file
-  done
-  rmdir $CID_FILE_DIR
-  : "Done."
-}
-
-# ct_enable_cleanup
-# --------------------
-# Enables automatic container cleanup after tests.
-function ct_enable_cleanup() {
-  trap ct_cleanup EXIT SIGINT
-}
-
-# ct_get_cid [name]
-# --------------------
-# Prints container id from cid_file based on the name of the file.
-# Argument: name - name of cid_file where the container id will be stored
-# Uses: $CID_FILE_DIR - path to directory containing cid_files
-function ct_get_cid() {
-  local name="$1" ; shift || return 1
-  echo $(cat "$CID_FILE_DIR/$name")
-}
-
-# ct_get_cip [id]
-# --------------------
-# Prints container ip address based on the container id.
-# Argument: id - container id
-function ct_get_cip() {
-  local id="$1" ; shift
-  docker inspect --format='{{.NetworkSettings.IPAddress}}' $(ct_get_cid "$id")
-}
-
-# ct_wait_for_cid [cid_file]
-# --------------------
-# Holds the execution until the cid_file is created. Usually run after container
-# creation.
-# Argument: cid_file - name of the cid_file that should be created
-function ct_wait_for_cid() {
-  local cid_file=$1
-  local max_attempts=10
-  local sleep_time=1
-  local attempt=1
-  local result=1
-  while [ $attempt -le $max_attempts ]; do
-    [ -f $cid_file ] && [ -s $cid_file ] && return 0
-    : "Waiting for container start..."
-    attempt=$(( $attempt + 1 ))
-    sleep $sleep_time
-  done
-  return 1
-}
-
-# ct_assert_container_creation_fails [container_args]
-# --------------------
-# The invocation of docker run should fail based on invalid container_args
-# passed to the function. Returns 0 when container fails to start properly.
-# Argument: container_args - all arguments are passed directly to dokcer run
-# Uses: $CID_FILE_DIR - path to directory containing cid_files
-function ct_assert_container_creation_fails() {
-  local ret=0
-  local max_attempts=10
-  local attempt=1
-  local cid_file=assert
-  set +e
-  local old_container_args="${CONTAINER_ARGS-}"
-  CONTAINER_ARGS="$@"
-  ct_create_container $cid_file
-  if [ $? -eq 0 ]; then
-    local cid=$(ct_get_cid $cid_file)
-
-    while [ "$(docker inspect -f '{{.State.Running}}' $cid)" == "true" ] ; do
-      sleep 2
-      attempt=$(( $attempt + 1 ))
-      if [ $attempt -gt $max_attempts ]; then
-        docker stop $cid
-        ret=1
-        break
-      fi
-    done
-    exit_status=$(docker inspect -f '{{.State.ExitCode}}' $cid)
-    if [ "$exit_status" == "0" ]; then
-      ret=1
-    fi
-    docker rm -v $cid
-    rm $CID_FILE_DIR/$cid_file
-  fi
-  [ ! -z $old_container_args ] && CONTAINER_ARGS="$old_container_args"
-  set -e
-  return $ret
-}
-
-# ct_create_container [name, command]
-# --------------------
-# Creates a container using the IMAGE_NAME and CONTAINER_ARGS variables. Also
-# stores the container id to a cid_file located in the CID_FILE_DIR, and waits
-# for the creation of the file.
-# Argument: name - name of cid_file where the container id will be stored
-# Argument: command - optional command to be executed in the container
-# Uses: $CID_FILE_DIR - path to directory containing cid_files
-# Uses: $CONTAINER_ARGS - optional arguments passed directly to docker run
-# Uses: $IMAGE_NAME - name of the image being tested
-function ct_create_container() {
-  local cid_file="$CID_FILE_DIR/$1" ; shift
-  # create container with a cidfile in a directory for cleanup
-  docker run --cidfile="$cid_file" -d ${CONTAINER_ARGS:-} $IMAGE_NAME "$@"
-  ct_wait_for_cid $cid_file || return 1
-  : "Created container $(cat $cid_file)"
-}
-
-# ct_scl_usage_old [name, command, expected]
-# --------------------
-# Tests three ways of running the SCL, by looking for an expected string
-# in the output of the command
-# Argument: name - name of cid_file where the container id will be stored
-# Argument: command - executed inside the container
-# Argument: expected - string that is expected to be in the command output
-# Uses: $CID_FILE_DIR - path to directory containing cid_files
-# Uses: $IMAGE_NAME - name of the image being tested
-function ct_scl_usage_old() {
-  local name="$1"
-  local command="$2"
-  local expected="$3"
-  local out=""
-  : "  Testing the image SCL enable"
-  out=$(docker run --rm ${IMAGE_NAME} /bin/bash -c "${command}")
-  if ! echo "${out}" | grep -q "${expected}"; then
-    echo "ERROR[/bin/bash -c "${command}"] Expected '${expected}', got '${out}'" >&2
-    return 1
-  fi
-  out=$(docker exec $(ct_get_cid $name) /bin/bash -c "${command}" 2>&1)
-  if ! echo "${out}" | grep -q "${expected}"; then
-    echo "ERROR[exec /bin/bash -c "${command}"] Expected '${expected}', got '${out}'" >&2
-    return 1
-  fi
-  out=$(docker exec $(ct_get_cid $name) /bin/sh -ic "${command}" 2>&1)
-  if ! echo "${out}" | grep -q "${expected}"; then
-    echo "ERROR[exec /bin/sh -ic "${command}"] Expected '${expected}', got '${out}'" >&2
-    return 1
-  fi
-}
-
-# ct_doc_content_old [strings]
-# --------------------
-# Looks for occurence of stirngs in the documentation files and checks
-# the format of the files. Files examined: help.1
-# Argument: strings - strings expected to appear in the documentation
-# Uses: $IMAGE_NAME - name of the image being tested
-function ct_doc_content_old() {
-  local tmpdir=$(mktemp -d)
-  local f
-  : "  Testing documentation in the container image"
-  # Extract the help files from the container
-  for f in help.1 ; do
-    docker run --rm ${IMAGE_NAME} /bin/bash -c "cat /${f}" >${tmpdir}/$(basename ${f})
-    # Check whether the files contain some important information
-    for term in $@ ; do
-      if ! cat ${tmpdir}/$(basename ${f}) | grep -F -q -e "${term}" ; then
-        echo "ERROR: File /${f} does not include '${term}'." >&2
-        return 1
-      fi
-    done
-    # Check whether the files use the correct format
-    for term in TH PP SH ; do
-      if ! grep -q "^\.${term}" ${tmpdir}/help.1 ; then
-        echo "ERROR: /help.1 is probably not in troff or groff format, since '${term}' is missing." >&2
-        return 1
-      fi
-    done
-  done
-  : "  Success!"
-}
-
-
-# ct_npm_works
-# --------------------
-# Checks existance of the npm tool and runs it.
-function ct_npm_works() {
-  local tmpdir=$(mktemp -d)
-  : "  Testing npm in the container image"
-  docker run --rm ${IMAGE_NAME} /bin/bash -c "npm --version" >${tmpdir}/version
-
-  if [ $? -ne 0 ] ; then
-    echo "ERROR: 'npm --version' does not work inside the image ${IMAGE_NAME}." >&2
-    return 1
-  fi
-
-  docker run --rm ${IMAGE_NAME} /bin/bash -c "npm install jquery && test -f node_modules/jquery/src/jquery.js"
-  if [ $? -ne 0 ] ; then
-    echo "ERROR: npm could not install jquery inside the image ${IMAGE_NAME}." >&2
-    return 1
-  fi
-
-  : "  Success!"
-}
-
-
-# ct_path_append PATH_VARNAME DIRECTORY
-# -------------------------------------
-# Append DIRECTORY to VARIABLE of name PATH_VARNAME, the VARIABLE must consist
-# of colon-separated list of directories.
-ct_path_append ()
-{
-    if eval "test -n \"\${$1-}\""; then
-        eval "$1=\$2:\$$1"
-    else
-        eval "$1=\$2"
-    fi
-}
-
-
-# ct_path_foreach PATH ACTION [ARGS ...]
-# --------------------------------------
-# For each DIR in PATH execute ACTION (path is colon separated list of
-# directories).  The particular calls to ACTION will look like
-# '$ ACTION directory [ARGS ...]'
-ct_path_foreach ()
-{
-    local dir dirlist action save_IFS
-    save_IFS=$IFS
-    IFS=:
-    dirlist=$1
-    action=$2
-    shift 2
-    for dir in $dirlist; do "$action" "$dir" "$@" ; done
-    IFS=$save_IFS
-}
-
-
-# ct_run_test_list
-# --------------------
-# Execute the tests specified by TEST_LIST
-# Uses: $TEST_LIST - list of test names
-function ct_run_test_list() {
-  for test_case in $TEST_LIST; do
-    : "Running test $test_case"
-    [ -f test/$test_case ] && source test/$test_case
-    [ -f ../test/$test_case ] && source ../test/$test_case
-    $test_case
-  done;
-}
-
-# ct_gen_self_signed_cert_pem
-# ---------------------------
-# Generates a self-signed PEM certificate pair into specified directory.
-# Argument: output_dir - output directory path
-# Argument: base_name - base name of the certificate files
-# Resulted files will be those:
-#   <output_dir>/<base_name>-cert-selfsigned.pem -- public PEM cert
-#   <output_dir>/<base_name>-key.pem -- PEM private key
-ct_gen_self_signed_cert_pem() {
-  local output_dir=$1 ; shift
-  local base_name=$1 ; shift
-  mkdir -p ${output_dir}
-  openssl req -newkey rsa:2048 -nodes -keyout ${output_dir}/${base_name}-key.pem -subj '/C=GB/ST=Berkshire/L=Newbury/O=My Server Company' > ${base_name}-req.pem
-  openssl req -new -x509 -nodes -key ${output_dir}/${base_name}-key.pem -batch > ${output_dir}/${base_name}-cert-selfsigned.pem
-}
-
-# ct_obtain_input FILE|DIR|URL
-# --------------------
-# Either copies a file or a directory to a tmp location for local copies, or
-# downloads the file from remote location.
-# Resulted file path is printed, so it can be later used by calling function.
-# Arguments: input - local file, directory or remote URL
-function ct_obtain_input() {
-  local input=$1
-  local extension="${input##*.}"
-
-  # Try to use same extension for the temporary file if possible
-  [[ "${extension}" =~ ^[a-z0-9]*$ ]] && extension=".${extension}" || extension=""
-
-  local output=$(mktemp "/var/tmp/test-input-XXXXXX$extension")
-  if [ -f "${input}" ] ; then
-    cp -f "${input}" "${output}"
-  elif [ -d "${input}" ] ; then
-    rm -f "${output}"
-    cp -r -LH "${input}" "${output}"
-  elif echo "${input}" | grep -qe '^http\(s\)\?://' ; then
-    curl "${input}" > "${output}"
-  else
-    echo "ERROR: file type not known: ${input}" >&2
-    return 1
-  fi
-  echo "${output}"
-}
-
-# ct_test_response
-# ----------------
-# Perform GET request to the application container, checks output with
-# a reg-exp and HTTP response code.
-# Argument: url - request URL path
-# Argument: expected_code - expected HTTP response code
-# Argument: body_regexp - PCRE regular expression that must match the response body
-# Argument: max_attempts - Optional number of attempts (default: 20), three seconds sleep between
-# Argument: ignore_error_attempts - Optional number of attempts when we ignore error output (default: 10)
-ct_test_response() {
-  local url="$1"
-  local expected_code="$2"
-  local body_regexp="$3"
-  local max_attempts=${4:-20}
-  local ignore_error_attempts=${5:-10}
-
-  : "  Testing the HTTP(S) response for <${url}>"
-  local sleep_time=3
-  local attempt=1
-  local result=1
-  local status
-  local response_code
-  local response_file=$(mktemp /tmp/ct_test_response_XXXXXX)
-  while [ ${attempt} -le ${max_attempts} ]; do
-    curl --connect-timeout 10 -s -w '%{http_code}' "${url}" >${response_file} && status=0 || status=1
-    if [ ${status} -eq 0 ]; then
-      response_code=$(cat ${response_file} | tail -c 3)
-      if [ "${response_code}" -eq "${expected_code}" ]; then
-        result=0
-      fi
-      cat ${response_file} | grep -qP -e "${body_regexp}" || result=1;
-      # Some services return 40x code until they are ready, so let's give them
-      # some chance and not end with failure right away
-      # Do not wait if we already have expected outcome though
-      if [ ${result} -eq 0 -o ${attempt} -gt ${ignore_error_attempts} -o ${attempt} -eq ${max_attempts} ] ; then
-        break
-      fi
-    fi
-    attempt=$(( ${attempt} + 1 ))
-    sleep ${sleep_time}
-  done
-  rm -f ${response_file}
-  return ${result}
-}
-
-# ct_registry_from_os OS
-# ----------------
-# Transform operating system string [os] into registry url
-# Argument: OS - string containing the os version
-ct_registry_from_os() {
-  local registry=""
-  case $1 in
-    rhel7)
-        registry=registry.access.redhat.com
-        ;;
-    *)
-        registry=docker.io
-        ;;
-    esac
-  echo "$registry"
-}
-
-# ct_assert_cmd_success CMD
-# ----------------
-# Evaluates [cmd] and fails if it does not succeed.
-# Argument: CMD - Command to be run
-function ct_assert_cmd_success() {
-  echo "Checking '$*' for success ..."
-  if ! eval "$@" &>/dev/null; then
-    echo " FAIL"
-    return 1
-  fi
-  echo " PASS"
-  return 0
-}
-
-# ct_assert_cmd_failure CMD
-# ----------------
-# Evaluates [cmd] and fails if it succeeds.
-# Argument: CMD - Command to be run
-function ct_assert_cmd_failure() {
-  echo "Checking '$*' for failure ..."
-  if eval "$@" &>/dev/null; then
-    echo " FAIL"
-    return 1
-  fi
-  echo " PASS"
-  return 0
-}
-
-
-# ct_random_string [LENGTH=10]
-# ----------------------------
-# Generate pseudorandom alphanumeric string of LENGTH bytes, the
-# default length is 10.  The string is printed on stdout.
-ct_random_string()
-(
-   export LC_ALL=C
-   dd if=/dev/urandom count=1 bs=10k 2>/dev/null \
-       | tr -dc 'a-z0-9' \
-       | fold -w "${1-10}" \
-       | head -n 1
-)
-
-# ct_s2i_usage IMG_NAME [S2I_ARGS]
-# ----------------------------
-# Create a container and run the usage script inside
-# Argument: IMG_NAME - name of the image to be used for the container run
-# Argument: S2I_ARGS - Additional list of source-to-image arguments, currently unused.
-ct_s2i_usage()
-{
-    local img_name=$1; shift
-    local s2i_args="$*";
-    local usage_command="/usr/libexec/s2i/usage"
-    docker run --rm "$img_name" bash -c "$usage_command"
-}
-
-# ct_s2i_build_as_df APP_PATH SRC_IMAGE DST_IMAGE [S2I_ARGS]
-# ----------------------------
-# Create a new s2i app image from local sources in a similar way as source-to-image would have used.
-# Argument: APP_PATH - local path to the app sources to be used in the test
-# Argument: SRC_IMAGE - image to be used as a base for the s2i build
-# Argument: DST_IMAGE - image name to be used during the tagging of the s2i build result
-# Argument: S2I_ARGS - Additional list of source-to-image arguments, currently only used to check for pull-policy=never.
-ct_s2i_build_as_df()
-{
-    local app_path=$1; shift
-    local src_image=$1; shift
-    local dst_image=$1; shift
-    local s2i_args="$*";
-    local local_app=upload/src/
-    local local_scripts=upload/scripts/
-    local user_id=
-    local df_name=
-    local tmpdir=
-    # Use /tmp to not pollute cwd
-    tmpdir=$(mktemp -d)
-    df_name=$(mktemp -p "$tmpdir" Dockerfile.XXXX)
-    pushd "$tmpdir"
-    # Check if the image is available locally and try to pull it if it is not
-    docker images "$src_image" &>/dev/null || echo "$s2i_args" | grep -q "pull-policy=never" || docker pull "$src_image"
-    user_id=$(docker inspect -f "{{.ContainerConfig.User}}" "$src_image")
-    # Strip file:// from APP_PATH and copy its contents into current context
-    mkdir -p "$local_app"
-    cp -r "${app_path/file:\/\//}/." "$local_app"
-    [ -d "$local_app/.s2i/bin/" ] && mv "$local_app/.s2i/bin" "$local_scripts"
-    # Create a Dockerfile named df_name and fill it with proper content
-    cat <<EOF >"$df_name"
-FROM $src_image
-LABEL "io.openshift.s2i.build.image"="$src_image" \\
-      "io.openshift.s2i.build.source-location"="$app_path"
-USER root
-COPY $local_app /tmp/src
-EOF
-    [ -d "$local_scripts" ] && echo "COPY $local_scripts /tmp/scripts" >> "$df_name" &&
-    echo "RUN chown -R $user_id:0 /tmp/scripts" >>"$df_name"
-    echo "RUN chown -R $user_id:0 /tmp/src" >>"$df_name"
-    # Check for custom environment variables
-    if [ -e "$local_app/.s2i/environment" ]; then
-        # Remove any comments and add the contents as ENV commands to the Dockerfile
-        sed '/^\s*#.*$/d' "$local_app/.s2i/environment" | while read -r line; do
-            echo "ENV $line" >>"$df_name"
-        done
-    fi
-    echo "USER $user_id" >>"$df_name"
-    # If exists, run the custom assemble script, else default to /usr/libexec/s2i/assemble
-    if [ -x "$local_scripts/assemble" ]; then
-        echo "RUN /tmp/scripts/assemble" >>"$df_name"
-    else
-        echo "RUN /usr/libexec/s2i/assemble" >>"$df_name"
-    fi
-    # If exists, set the custom run script as CMD, else default to /usr/libexec/s2i/run
-    if [ -x "$local_scripts/run" ]; then
-        echo "CMD /tmp/scripts/run" >>"$df_name"
-    else
-        echo "CMD /usr/libexec/s2i/run" >>"$df_name"
-    fi
-    # Run the build and tag the result
-    docker build -f "$df_name" -t "$dst_image" .
-    popd
-}