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

Pull changes from upstream repository

Browse source
This commit is contained in:
Marek Skalický 2018-11-06 14:18:31 +00:00
commit 458834b40f
No known key found for this signature in database
GPG key ID: ADCAA1DEE100A66D
23 changed files with 1393 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

1
2.5 Symbolic link
View file

@ -0,0 +1 @@
.

51
Dockerfile Normal file
View file

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

1
Dockerfile.fedora Symbolic link
View file

@ -0,0 +1 @@
Dockerfile

146
README.md Normal file
View file

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

1
help.md Symbolic link
View file

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

250
root/help.1 Normal file
View file

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

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

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

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

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

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

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

71
s2i/bin/assemble Executable file
View file

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

39
s2i/bin/run Executable file
View file

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

18
s2i/bin/usage Executable file
View file

@ -0,0 +1,18 @@
#!/bin/sh
DISTRO=`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

0
sources
View file

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

186
test/run Executable file
View file

@ -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."

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

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