From 458834b40ff0063c70924c08ab147be8246d577e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marek=20Skalick=C3=BD?= Date: Tue, 6 Nov 2018 14:18:31 +0000 Subject: [PATCH] Pull changes from upstream repository --- 2.5 | 1 + Dockerfile | 51 ++++ Dockerfile.fedora | 1 + README.md | 146 +++++++++ help.md | 1 + root/help.1 | 250 +++++++++++++++ root/opt/app-root/.gemrc | 9 + root/opt/app-root/etc/puma.cfg | 50 +++ root/opt/app-root/etc/scl_enable | 6 + s2i/bin/assemble | 71 +++++ s2i/bin/run | 39 +++ s2i/bin/usage | 18 ++ sources | 0 test/puma-test-app/Gemfile | 4 + test/puma-test-app/Gemfile.lock | 21 ++ test/puma-test-app/app.rb | 5 + test/puma-test-app/config.ru | 2 + test/rack-test-app/Gemfile | 3 + test/rack-test-app/Gemfile.lock | 19 ++ test/rack-test-app/app.rb | 5 + test/rack-test-app/config.ru | 2 + test/run | 186 ++++++++++++ test/test-lib.sh | 503 +++++++++++++++++++++++++++++++ 23 files changed, 1393 insertions(+) create mode 120000 2.5 create mode 100644 Dockerfile create mode 120000 Dockerfile.fedora create mode 100644 README.md create mode 120000 help.md create mode 100644 root/help.1 create mode 100644 root/opt/app-root/.gemrc create mode 100644 root/opt/app-root/etc/puma.cfg create mode 100644 root/opt/app-root/etc/scl_enable create mode 100755 s2i/bin/assemble create mode 100755 s2i/bin/run create mode 100755 s2i/bin/usage delete mode 100644 sources create mode 100755 test/puma-test-app/Gemfile create mode 100644 test/puma-test-app/Gemfile.lock create mode 100755 test/puma-test-app/app.rb create mode 100755 test/puma-test-app/config.ru create mode 100755 test/rack-test-app/Gemfile create mode 100644 test/rack-test-app/Gemfile.lock create mode 100755 test/rack-test-app/app.rb create mode 100755 test/rack-test-app/config.ru create mode 100755 test/run create mode 100644 test/test-lib.sh diff --git a/2.5 b/2.5 new file mode 120000 index 0000000..945c9b4 --- /dev/null +++ b/2.5 @@ -0,0 +1 @@ +. \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..93cdb1b --- /dev/null +++ b/Dockerfile @@ -0,0 +1,51 @@ +FROM registry.fedoraproject.org/f28/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 " + +# 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 new file mode 120000 index 0000000..1d1fe94 --- /dev/null +++ b/Dockerfile.fedora @@ -0,0 +1 @@ +Dockerfile \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..94bddf3 --- /dev/null +++ b/README.md @@ -0,0 +1,146 @@ +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 /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/help.md b/help.md new file mode 120000 index 0000000..42061c0 --- /dev/null +++ b/help.md @@ -0,0 +1 @@ +README.md \ No newline at end of file diff --git a/root/help.1 b/root/help.1 new file mode 100644 index 0000000..e5c88b5 --- /dev/null +++ b/root/help.1 @@ -0,0 +1,250 @@ +.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 /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 new file mode 100644 index 0000000..2422bea --- /dev/null +++ b/root/opt/app-root/.gemrc @@ -0,0 +1,9 @@ +--- +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 new file mode 100644 index 0000000..a52d26d --- /dev/null +++ b/root/opt/app-root/etc/puma.cfg @@ -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' diff --git a/root/opt/app-root/etc/scl_enable b/root/opt/app-root/etc/scl_enable new file mode 100644 index 0000000..826d94c --- /dev/null +++ b/root/opt/app-root/etc/scl_enable @@ -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 rh-ruby25 $NODEJS_SCL diff --git a/s2i/bin/assemble b/s2i/bin/assemble new file mode 100755 index 0000000..f3a4b8d --- /dev/null +++ b/s2i/bin/assemble @@ -0,0 +1,71 @@ +#!/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 new file mode 100755 index 0000000..1614ec3 --- /dev/null +++ b/s2i/bin/run @@ -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 diff --git a/s2i/bin/usage b/s2i/bin/usage new file mode 100755 index 0000000..c04792f --- /dev/null +++ b/s2i/bin/usage @@ -0,0 +1,18 @@ +#!/bin/sh + +DISTRO=`cat /etc/*-release | grep ^ID= | grep -Po '".*?"' | tr -d '"'` +NAMESPACE=centos +[[ $DISTRO =~ rhel* ]] && NAMESPACE=rhscl + +cat < 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 new file mode 100755 index 0000000..cd7e87d --- /dev/null +++ b/test/puma-test-app/app.rb @@ -0,0 +1,5 @@ +require 'sinatra' + +get '/' do + 'Hello world!' +end diff --git a/test/puma-test-app/config.ru b/test/puma-test-app/config.ru new file mode 100755 index 0000000..76a6edf --- /dev/null +++ b/test/puma-test-app/config.ru @@ -0,0 +1,2 @@ +require './app' +run Sinatra::Application diff --git a/test/rack-test-app/Gemfile b/test/rack-test-app/Gemfile new file mode 100755 index 0000000..c10abd7 --- /dev/null +++ b/test/rack-test-app/Gemfile @@ -0,0 +1,3 @@ +source 'https://rubygems.org' + +gem 'sinatra' diff --git a/test/rack-test-app/Gemfile.lock b/test/rack-test-app/Gemfile.lock new file mode 100644 index 0000000..1569406 --- /dev/null +++ b/test/rack-test-app/Gemfile.lock @@ -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 diff --git a/test/rack-test-app/app.rb b/test/rack-test-app/app.rb new file mode 100755 index 0000000..cd7e87d --- /dev/null +++ b/test/rack-test-app/app.rb @@ -0,0 +1,5 @@ +require 'sinatra' + +get '/' do + 'Hello world!' +end diff --git a/test/rack-test-app/config.ru b/test/rack-test-app/config.ru new file mode 100755 index 0000000..76a6edf --- /dev/null +++ b/test/rack-test-app/config.ru @@ -0,0 +1,2 @@ +require './app' +run Sinatra::Application diff --git a/test/run b/test/run new file mode 100755 index 0000000..9a44b81 --- /dev/null +++ b/test/run @@ -0,0 +1,186 @@ +#!/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 new file mode 100644 index 0000000..c381d45 --- /dev/null +++ b/test/test-lib.sh @@ -0,0 +1,503 @@ +# +# Test a container image. +# +# Always use sourced from a specific container testfile +# +# reguires definition of CID_FILE_DIR +# CID_FILE_DIR=$(mktemp --suffix=_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: +# /-cert-selfsigned.pem -- public PEM cert +# /-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 <"$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 +}