Compare commits
3 commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
e9361042c5 | ||
|
c504691648 | ||
|
5cd1e59d71 |
30 changed files with 1 additions and 1641 deletions
0
.gitignore
vendored
0
.gitignore
vendored
1
2.6
1
2.6
|
|
@ -1 +0,0 @@
|
||||||
.
|
|
||||||
51
Dockerfile
51
Dockerfile
|
|
@ -1,51 +0,0 @@
|
||||||
FROM registry.fedoraproject.org/f31/s2i-base
|
|
||||||
|
|
||||||
# This image provides a Ruby environment you can use to run your Ruby
|
|
||||||
# applications.
|
|
||||||
|
|
||||||
EXPOSE 8080
|
|
||||||
|
|
||||||
ENV NAME=ruby \
|
|
||||||
RUBY_VERSION=2.6 \
|
|
||||||
RUBY_SHORT_VER=26 \
|
|
||||||
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 +0,0 @@
|
||||||
Dockerfile
|
|
||||||
145
README.md
145
README.md
|
|
@ -1,145 +0,0 @@
|
||||||
Ruby 2.6 container image
|
|
||||||
=================
|
|
||||||
This container image includes Ruby 2.6 as a [S2I](https://github.com/openshift/source-to-image) base image for your Ruby 2.6 applications.
|
|
||||||
Users can choose between RHEL, CentOS and Fedora based builder images.
|
|
||||||
The RHEL images are available in the [Red Hat Container Catalog](https://access.redhat.com/containers/),
|
|
||||||
the CentOS images are available on [Docker Hub](https://hub.docker.com/r/centos/),
|
|
||||||
and the Fedora images are available in [Fedora Registry](https://registry.fedoraproject.org/).
|
|
||||||
The resulting image can be run using [podman](https://github.com/containers/libpod).
|
|
||||||
|
|
||||||
Note: while the examples in this README are calling `podman`, you can replace any such calls by `docker` with the same arguments
|
|
||||||
|
|
||||||
Description
|
|
||||||
-----------
|
|
||||||
|
|
||||||
Ruby 2.6 available as container is a base platform for
|
|
||||||
building and running various Ruby 2.6 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
|
|
||||||
---------------------
|
|
||||||
For this, we will assume that you are using the `ubi8/ruby-26 image`, available via `ruby:2.6` imagestream tag in Openshift.
|
|
||||||
Building a simple [ruby-sample-app](https://github.com/sclorg/s2i-ruby-container/tree/master/2.6/test/puma-test-app) application
|
|
||||||
in Openshift can be achieved with the following step:
|
|
||||||
|
|
||||||
```
|
|
||||||
$ oc new-app ruby:2.6~https://github.com/sclorg/s2i-ruby-container.git --context-dir=2.6/test/puma-test-app/
|
|
||||||
```
|
|
||||||
|
|
||||||
The same application can also be built using the standalone [S2I](https://github.com/openshift/source-to-image) application on systems that have it available:
|
|
||||||
|
|
||||||
```
|
|
||||||
$ s2i build https://github.com/sclorg/s2i-ruby-container.git --context-dir=2.6/test/puma-test-app/ ubi8/ruby-26 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 `.s2i/environment`
|
|
||||||
file inside your source code repository.
|
|
||||||
|
|
||||||
* **RACK_ENV**
|
|
||||||
|
|
||||||
This variable specifies the environment where the Ruby application will be deployed (unless overwritten) - `production`, `development`, `test`.
|
|
||||||
Each level has different behaviors in terms of logging verbosity, error pages, ruby gem installation, etc.
|
|
||||||
|
|
||||||
**Note**: Application assets will be compiled only if the `RACK_ENV` is set to `production`
|
|
||||||
|
|
||||||
* **DISABLE_ASSET_COMPILATION**
|
|
||||||
|
|
||||||
This variable set to `true` indicates that the asset compilation process will be skipped. Since this only takes place
|
|
||||||
when the application is run in the `production` environment, it should only be used when assets are already compiled.
|
|
||||||
|
|
||||||
* **PUMA_MIN_THREADS**, **PUMA_MAX_THREADS**
|
|
||||||
|
|
||||||
These variables indicate the minimum and maximum threads that will be available in [Puma](https://github.com/puma/puma)'s thread pool.
|
|
||||||
|
|
||||||
* **PUMA_WORKERS**
|
|
||||||
|
|
||||||
This variable indicate the number of worker processes that will be launched. See documentation on Puma's [clustered mode](https://github.com/puma/puma#clustered-mode).
|
|
||||||
|
|
||||||
* **RUBYGEM_MIRROR**
|
|
||||||
|
|
||||||
Set this variable to use a custom RubyGems mirror URL to download required gem packages during build process.
|
|
||||||
|
|
||||||
Hot deploy
|
|
||||||
---------------------
|
|
||||||
In order to dynamically pick up changes made in your application source code, you need to make following steps:
|
|
||||||
|
|
||||||
* **For Ruby on Rails applications**
|
|
||||||
|
|
||||||
Run the built Rails image with the `RAILS_ENV=development` environment variable passed to the [podman](https://github.com/containers/libpod) `-e` run flag:
|
|
||||||
```
|
|
||||||
$ podman run -e RAILS_ENV=development -p 8080:8080 rails-app
|
|
||||||
```
|
|
||||||
* **For other types of Ruby applications (Sinatra, Padrino, etc.)**
|
|
||||||
|
|
||||||
Your application needs to be built with one of gems that reloads the server every time changes in source code are done inside the running container. Those gems are:
|
|
||||||
* [Shotgun](https://github.com/rtomayko/shotgun)
|
|
||||||
* [Rerun](https://github.com/alexch/rerun)
|
|
||||||
* [Rack-livereload](https://github.com/johnbintz/rack-livereload)
|
|
||||||
|
|
||||||
Please note that in order to be able to run your application in development mode, you need to modify the [S2I run script](https://github.com/openshift/source-to-image#anatomy-of-a-builder-image), so the web server is launched by the chosen gem, which checks for changes in the source code.
|
|
||||||
|
|
||||||
After you built your application image with your version of [S2I run script](https://github.com/openshift/source-to-image#anatomy-of-a-builder-image), run the image with the RACK_ENV=development environment variable passed to the [podman](https://github.com/containers/libpod) -e run flag:
|
|
||||||
```
|
|
||||||
$ podman run -e RACK_ENV=development -p 8080:8080 sinatra-app
|
|
||||||
```
|
|
||||||
|
|
||||||
To change your source code in running container, use Podman's [exec](https://github.com/containers/libpod) command:
|
|
||||||
```
|
|
||||||
$ podman exec -it <CONTAINER_ID> /bin/bash
|
|
||||||
```
|
|
||||||
|
|
||||||
After you [podman exec](https://github.com/containers/libpod) into the running container, your current
|
|
||||||
directory is set to `/opt/app-root/src`, where the source code is located.
|
|
||||||
|
|
||||||
Performance tuning
|
|
||||||
---------------------
|
|
||||||
You can tune the number of threads per worker using the
|
|
||||||
`PUMA_MIN_THREADS` and `PUMA_MAX_THREADS` environment variables.
|
|
||||||
Additionally, the number of worker processes is determined by the number of CPU
|
|
||||||
cores that the container has available, as recommended by
|
|
||||||
[Puma](https://github.com/puma/puma)'s documentation. This is determined using
|
|
||||||
the cgroup [cpusets](https://www.kernel.org/doc/Documentation/cgroup-v1/cpusets.txt)
|
|
||||||
subsystem. You can specify the cores that the container is allowed to use by passing
|
|
||||||
the `--cpuset-cpus` parameter to the [podman](https://github.com/containers/libpod) run command:
|
|
||||||
```
|
|
||||||
$ podman run -e PUMA_MAX_THREADS=32 --cpuset-cpus='0-2,3,5' -p 8080:8080 sinatra-app
|
|
||||||
```
|
|
||||||
The number of workers is also limited by the memory limit that is enforced using
|
|
||||||
cgroups. The builder image assumes that you will need 50 MiB as a base and
|
|
||||||
another 15 MiB for every worker process plus 128 KiB for each thread. Note that
|
|
||||||
each worker has its own threads, so the total memory required for the whole
|
|
||||||
container is computed using the following formula:
|
|
||||||
|
|
||||||
```
|
|
||||||
50 + 15 * WORKERS + 0.125 * WORKERS * PUMA_MAX_THREADS
|
|
||||||
```
|
|
||||||
You can specify a memory limit using the `--memory` flag:
|
|
||||||
```
|
|
||||||
$ podman run -e PUMA_MAX_THREADS=32 --memory=300m -p 8080:8080 sinatra-app
|
|
||||||
```
|
|
||||||
If memory is more limiting then the number of available cores, the number of
|
|
||||||
workers is scaled down accordingly to fit the above formula. The number of
|
|
||||||
workers can also be set explicitly by setting `PUMA_WORKERS`.
|
|
||||||
|
|
||||||
|
|
||||||
See also
|
|
||||||
--------
|
|
||||||
Dockerfile and other sources are available on https://github.com/sclorg/s2i-ruby-container.
|
|
||||||
In that repository you also can find another versions of Ruby environment Dockerfiles.
|
|
||||||
Dockerfile for CentOS is called `Dockerfile`, Dockerfile for RHEL7 is called `Dockerfile.rhel7`,
|
|
||||||
for RHEL8 it's `Dockerfile.rhel8` and the Fedora Dockerfile is called Dockerfile.fedora.
|
|
||||||
1
dead.package
Normal file
1
dead.package
Normal file
|
|
@ -0,0 +1 @@
|
||||||
|
container sources not used for building fedora containers anymore
|
||||||
1
help.md
1
help.md
|
|
@ -1 +0,0 @@
|
||||||
README.md
|
|
||||||
264
root/help.1
264
root/help.1
|
|
@ -1,264 +0,0 @@
|
||||||
.TH Ruby 2.6 container image
|
|
||||||
.PP
|
|
||||||
This container image includes Ruby 2.6 as a S2I
|
|
||||||
\[la]https://github.com/openshift/source-to-image\[ra] base image for your Ruby 2.6 applications.
|
|
||||||
Users can choose between RHEL, CentOS and Fedora based builder images.
|
|
||||||
The RHEL images are available in the Red Hat Container Catalog
|
|
||||||
\[la]https://access.redhat.com/containers/\[ra],
|
|
||||||
the CentOS images are available on Docker Hub
|
|
||||||
\[la]https://hub.docker.com/r/centos/\[ra],
|
|
||||||
and the Fedora images are available in Fedora Registry
|
|
||||||
\[la]https://registry.fedoraproject.org/\[ra]\&.
|
|
||||||
The resulting image can be run using podman
|
|
||||||
\[la]https://github.com/containers/libpod\[ra]\&.
|
|
||||||
|
|
||||||
.PP
|
|
||||||
Note: while the examples in this README are calling \fB\fCpodman\fR, you can replace any such calls by \fB\fCdocker\fR with the same arguments
|
|
||||||
|
|
||||||
.SH Description
|
|
||||||
.PP
|
|
||||||
Ruby 2.6 available as container is a base platform for
|
|
||||||
building and running various Ruby 2.6 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
|
|
||||||
For this, we will assume that you are using the \fB\fCubi8/ruby\-26 image\fR, available via \fB\fCruby:2.6\fR imagestream tag in Openshift.
|
|
||||||
Building a simple ruby\-sample\-app
|
|
||||||
\[la]https://github.com/sclorg/s2i-ruby-container/tree/master/2.6/test/puma-test-app\[ra] application
|
|
||||||
in Openshift can be achieved with the following step:
|
|
||||||
|
|
||||||
.PP
|
|
||||||
.RS
|
|
||||||
|
|
||||||
.nf
|
|
||||||
```
|
|
||||||
$ oc new\-app ruby:2.6\~https://github.com/sclorg/s2i\-ruby\-container.git \-\-context\-dir=2.6/test/puma\-test\-app/
|
|
||||||
```
|
|
||||||
|
|
||||||
.fi
|
|
||||||
.RE
|
|
||||||
|
|
||||||
.PP
|
|
||||||
The same application can also be built using the standalone S2I
|
|
||||||
\[la]https://github.com/openshift/source-to-image\[ra] application on systems that have it available:
|
|
||||||
|
|
||||||
.PP
|
|
||||||
.RS
|
|
||||||
|
|
||||||
.nf
|
|
||||||
```
|
|
||||||
$ s2i build https://github.com/sclorg/s2i\-ruby\-container.git \-\-context\-dir=2.6/test/puma\-test\-app/ ubi8/ruby\-26 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\&.s2i/environment\fR
|
|
||||||
file inside your source code repository.
|
|
||||||
|
|
||||||
.RS
|
|
||||||
.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.
|
|
||||||
|
|
||||||
.RE
|
|
||||||
|
|
||||||
.SH Hot deploy
|
|
||||||
.PP
|
|
||||||
In order to dynamically pick up changes made in your application source code, you need to make following steps:
|
|
||||||
|
|
||||||
.RS
|
|
||||||
.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 podman
|
|
||||||
\[la]https://github.com/containers/libpod\[ra] \fB\fC\-e\fR run flag:
|
|
||||||
|
|
||||||
.PP
|
|
||||||
.RS
|
|
||||||
|
|
||||||
.nf
|
|
||||||
$ podman 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:
|
|
||||||
|
|
||||||
.RS
|
|
||||||
.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]
|
|
||||||
|
|
||||||
.RE
|
|
||||||
|
|
||||||
.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 podman
|
|
||||||
\[la]https://github.com/containers/libpod\[ra] \-e run flag:
|
|
||||||
|
|
||||||
.PP
|
|
||||||
.RS
|
|
||||||
|
|
||||||
.nf
|
|
||||||
$ podman run \-e RACK\_ENV=development \-p 8080:8080 sinatra\-app
|
|
||||||
|
|
||||||
.fi
|
|
||||||
.RE
|
|
||||||
|
|
||||||
.RE
|
|
||||||
|
|
||||||
.PP
|
|
||||||
To change your source code in running container, use Podman's exec
|
|
||||||
\[la]https://github.com/containers/libpod\[ra] command:
|
|
||||||
|
|
||||||
.PP
|
|
||||||
.RS
|
|
||||||
|
|
||||||
.nf
|
|
||||||
$ podman exec \-it <CONTAINER\_ID> /bin/bash
|
|
||||||
|
|
||||||
.fi
|
|
||||||
.RE
|
|
||||||
|
|
||||||
.PP
|
|
||||||
After you podman exec
|
|
||||||
\[la]https://github.com/containers/libpod\[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 podman
|
|
||||||
\[la]https://github.com/containers/libpod\[ra] run command:
|
|
||||||
|
|
||||||
.PP
|
|
||||||
.RS
|
|
||||||
|
|
||||||
.nf
|
|
||||||
$ podman 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
|
|
||||||
$ podman 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 Ruby environment Dockerfiles.
|
|
||||||
Dockerfile for CentOS is called \fB\fCDockerfile\fR, Dockerfile for RHEL7 is called \fB\fCDockerfile.rhel7\fR,
|
|
||||||
for RHEL8 it's \fB\fCDockerfile.rhel8\fR and the Fedora Dockerfile is called Dockerfile.fedora.
|
|
||||||
|
|
@ -1,9 +0,0 @@
|
||||||
---
|
|
||||||
install: --no-document
|
|
||||||
update: --no-document
|
|
||||||
:benchmark: false
|
|
||||||
:update_sources: true
|
|
||||||
:bulk_threshold: 1000
|
|
||||||
:backtrace: true
|
|
||||||
:sources:
|
|
||||||
- https://rubygems.org/
|
|
||||||
|
|
@ -1,50 +0,0 @@
|
||||||
def get_max_memory()
|
|
||||||
return ENV['MEMORY_LIMIT_IN_BYTES'].to_i if ENV.has_key? 'MEMORY_LIMIT_IN_BYTES'
|
|
||||||
|
|
||||||
# Assume unlimited memory. 0.size is the number of bytes a Ruby
|
|
||||||
# Fixnum class can hold. One bit is used for sign and one is used
|
|
||||||
# by Ruby to determine whether it's a number or pointer to an object.
|
|
||||||
# That's why we subtract two bits. This expresion should therefore be
|
|
||||||
# the largest signed Fixnum possible.
|
|
||||||
(2 ** (8*0.size - 2) - 1)
|
|
||||||
end
|
|
||||||
|
|
||||||
def get_memory_per_worker()
|
|
||||||
bytes = ENV.fetch('MEMORY_BYTES_PER_WORKER', '0').to_i
|
|
||||||
if bytes == 0
|
|
||||||
# Comment describing rationale for choosing default of 256MiB/worker is below.
|
|
||||||
bytes = 256 * (2**20)
|
|
||||||
end
|
|
||||||
bytes
|
|
||||||
end
|
|
||||||
|
|
||||||
def get_min_threads()
|
|
||||||
ENV.fetch('PUMA_MIN_THREADS', '0').to_i
|
|
||||||
end
|
|
||||||
|
|
||||||
def get_max_threads()
|
|
||||||
ENV.fetch('PUMA_MAX_THREADS', '16').to_i
|
|
||||||
end
|
|
||||||
|
|
||||||
# Determine the maximum number of workers that are allowed by the available
|
|
||||||
# memory. Puma documentation recommends the maximum number of workers to be
|
|
||||||
# set to the number of cores.
|
|
||||||
# Unless we're specifically tuned otherwise, allow one worker process per 256MiB
|
|
||||||
# memory, to a maximum of 1 worker / core. Hopefully that'll be a reasonable
|
|
||||||
# starting point for average apps; if not, it's all tunable. The simple
|
|
||||||
# OpenShift ruby/rails sample app currently requires approx. 60MiB +
|
|
||||||
# 70MiB/worker before taking its first request, so hopefully a default of
|
|
||||||
# 256MiB/worker will give other simple apps reasonable default headroom.
|
|
||||||
def get_workers()
|
|
||||||
return ENV['PUMA_WORKERS'].to_i if ENV.has_key? 'PUMA_WORKERS'
|
|
||||||
|
|
||||||
cores = ENV.fetch('NUMBER_OF_CORES', '1').to_i
|
|
||||||
max_workers = get_max_memory() / get_memory_per_worker()
|
|
||||||
|
|
||||||
[cores, max_workers].min
|
|
||||||
end
|
|
||||||
|
|
||||||
environment ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'production'
|
|
||||||
threads get_min_threads(), get_max_threads()
|
|
||||||
workers get_workers()
|
|
||||||
bind 'tcp://0.0.0.0:8080'
|
|
||||||
|
|
@ -1,6 +0,0 @@
|
||||||
# IMPORTANT: Do not add more content to this file unless you know what you are
|
|
||||||
# doing. This file is sourced everytime the shell session is opened.
|
|
||||||
#
|
|
||||||
# This will make scl collection binaries work out of box.
|
|
||||||
unset BASH_ENV PROMPT_COMMAND ENV
|
|
||||||
source scl_source enable rh-ruby26 $NODEJS_SCL
|
|
||||||
|
|
@ -1,67 +0,0 @@
|
||||||
#!/bin/bash
|
|
||||||
|
|
||||||
function rake_assets_precompile() {
|
|
||||||
[[ "$DISABLE_ASSET_COMPILATION" == "true" ]] && return
|
|
||||||
[ ! -f Gemfile ] && return
|
|
||||||
[ ! -f Rakefile ] && return
|
|
||||||
! grep " rake " Gemfile.lock >/dev/null && return
|
|
||||||
! bundle exec 'rake -T' | grep "assets:precompile" >/dev/null && return
|
|
||||||
|
|
||||||
echo "---> Starting asset compilation ..."
|
|
||||||
bundle exec rake assets:precompile
|
|
||||||
}
|
|
||||||
|
|
||||||
set -e
|
|
||||||
|
|
||||||
export RACK_ENV=${RACK_ENV:-"production"}
|
|
||||||
|
|
||||||
if [ -n "$RUBYGEM_MIRROR" ]; then
|
|
||||||
bundle config mirror.https://rubygems.org $RUBYGEM_MIRROR
|
|
||||||
fi
|
|
||||||
|
|
||||||
shopt -s dotglob
|
|
||||||
echo "---> Installing application source ..."
|
|
||||||
mv /tmp/src/* ./
|
|
||||||
|
|
||||||
# Change the npm registry mirror if provided
|
|
||||||
if [ -n "$NPM_MIRROR" ]; then
|
|
||||||
npm config set registry $NPM_MIRROR
|
|
||||||
fi
|
|
||||||
|
|
||||||
echo "---> Building your Ruby application from source ..."
|
|
||||||
if [ -f Gemfile ]; then
|
|
||||||
ADDTL_BUNDLE_ARGS="--retry 2"
|
|
||||||
if [ -f Gemfile.lock ]; then
|
|
||||||
ADDTL_BUNDLE_ARGS+=" --deployment"
|
|
||||||
fi
|
|
||||||
|
|
||||||
if [[ "$RAILS_ENV" == "development" || "$RACK_ENV" == "development" ]]; then
|
|
||||||
BUNDLE_WITHOUT=${BUNDLE_WITHOUT:-"test"}
|
|
||||||
elif [[ "$RAILS_ENV" == "test" || "$RACK_ENV" == "test" ]]; then
|
|
||||||
BUNDLE_WITHOUT=${BUNDLE_WITHOUT:-"development"}
|
|
||||||
else
|
|
||||||
BUNDLE_WITHOUT=${BUNDLE_WITHOUT:-"development:test"}
|
|
||||||
fi
|
|
||||||
|
|
||||||
if [ -n "$BUNDLE_WITHOUT" ]; then
|
|
||||||
ADDTL_BUNDLE_ARGS+=" --without $BUNDLE_WITHOUT"
|
|
||||||
fi
|
|
||||||
|
|
||||||
echo "---> Running 'bundle install ${ADDTL_BUNDLE_ARGS}' ..."
|
|
||||||
bundle install --path ./bundle ${ADDTL_BUNDLE_ARGS}
|
|
||||||
|
|
||||||
echo "---> Cleaning up unused ruby gems ..."
|
|
||||||
bundle clean -V
|
|
||||||
fi
|
|
||||||
|
|
||||||
if ! bundle exec rackup -h &>/dev/null; then
|
|
||||||
echo "WARNING: Rubygem Rack is not installed in the present image."
|
|
||||||
echo " Add rack to your Gemfile in order to start the web server."
|
|
||||||
fi
|
|
||||||
|
|
||||||
if [[ "$RAILS_ENV" == "production" || "$RACK_ENV" == "production" ]]; then
|
|
||||||
rake_assets_precompile
|
|
||||||
fi
|
|
||||||
|
|
||||||
# Fix source directory permissions
|
|
||||||
fix-permissions ./
|
|
||||||
39
s2i/bin/run
39
s2i/bin/run
|
|
@ -1,39 +0,0 @@
|
||||||
#!/bin/bash
|
|
||||||
|
|
||||||
function is_puma_installed() {
|
|
||||||
[ ! -f Gemfile.lock ] && return 1
|
|
||||||
grep ' puma ' Gemfile.lock >/dev/null
|
|
||||||
}
|
|
||||||
|
|
||||||
set -e
|
|
||||||
|
|
||||||
function check_number() {
|
|
||||||
if [[ ! "$2" =~ ^[0-9]+$ ]]; then
|
|
||||||
echo "$1 needs to be a non-negative number"
|
|
||||||
exit 1
|
|
||||||
fi
|
|
||||||
}
|
|
||||||
check_number PUMA_WORKERS "${PUMA_WORKERS:-0}"
|
|
||||||
check_number PUMA_MIN_THREADS "${PUMA_MIN_THREADS:-0}"
|
|
||||||
check_number PUMA_MAX_THREADS "${PUMA_MAX_THREADS:-0}"
|
|
||||||
|
|
||||||
export RACK_ENV=${RACK_ENV:-"production"}
|
|
||||||
|
|
||||||
if is_puma_installed; then
|
|
||||||
export_vars=$(cgroup-limits) ; export $export_vars
|
|
||||||
|
|
||||||
exec bundle exec "puma --config ../etc/puma.cfg"
|
|
||||||
else
|
|
||||||
echo "You might consider adding 'puma' into your Gemfile."
|
|
||||||
|
|
||||||
if bundle exec rackup -h &>/dev/null; then
|
|
||||||
if [ -f Gemfile ]; then
|
|
||||||
exec bundle exec "rackup -E ${RAILS_ENV:-$RACK_ENV} -P /tmp/rack.pid --host 0.0.0.0 --port 8080"
|
|
||||||
else
|
|
||||||
exec rackup -E "${RAILS_ENV:-$RACK_ENV}" -P /tmp/rack.pid --host 0.0.0.0 --port 8080
|
|
||||||
fi
|
|
||||||
else
|
|
||||||
echo "ERROR: Rubygem Rack is not installed in the present image."
|
|
||||||
echo " Add rack to your Gemfile in order to start the web server."
|
|
||||||
fi
|
|
||||||
fi
|
|
||||||
|
|
@ -1,16 +0,0 @@
|
||||||
#!/bin/sh
|
|
||||||
|
|
||||||
DISTRO="`grep ^ID= /etc/*-release | cut -d'"' -f2`"
|
|
||||||
|
|
||||||
cat <<EOF
|
|
||||||
This is a S2I ruby-${RUBY_VERSION} ${DISTRO} base image:
|
|
||||||
To use it, 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/ ${IMAGE_NAME} ruby-sample-app
|
|
||||||
|
|
||||||
|
|
||||||
You can then run the resulting image via:
|
|
||||||
podman run -p 8080:8080 ruby-sample-app
|
|
||||||
EOF
|
|
||||||
|
|
@ -1,4 +0,0 @@
|
||||||
source 'https://rubygems.org'
|
|
||||||
|
|
||||||
gem 'sinatra'
|
|
||||||
gem 'puma'
|
|
||||||
|
|
@ -1,21 +0,0 @@
|
||||||
GEM
|
|
||||||
remote: https://rubygems.org/
|
|
||||||
specs:
|
|
||||||
mustermann (1.0.1)
|
|
||||||
puma (3.11.2)
|
|
||||||
rack (2.0.4)
|
|
||||||
rack-protection (2.0.0)
|
|
||||||
rack
|
|
||||||
sinatra (2.0.0)
|
|
||||||
mustermann (~> 1.0)
|
|
||||||
rack (~> 2.0)
|
|
||||||
rack-protection (= 2.0.0)
|
|
||||||
tilt (~> 2.0)
|
|
||||||
tilt (2.0.8)
|
|
||||||
|
|
||||||
PLATFORMS
|
|
||||||
ruby
|
|
||||||
|
|
||||||
DEPENDENCIES
|
|
||||||
puma
|
|
||||||
sinatra
|
|
||||||
|
|
@ -1,5 +0,0 @@
|
||||||
require 'sinatra'
|
|
||||||
|
|
||||||
get '/' do
|
|
||||||
'Hello world!'
|
|
||||||
end
|
|
||||||
|
|
@ -1,2 +0,0 @@
|
||||||
require './app'
|
|
||||||
run Sinatra::Application
|
|
||||||
|
|
@ -1,3 +0,0 @@
|
||||||
source 'https://rubygems.org'
|
|
||||||
|
|
||||||
gem 'sinatra'
|
|
||||||
|
|
@ -1,19 +0,0 @@
|
||||||
GEM
|
|
||||||
remote: https://rubygems.org/
|
|
||||||
specs:
|
|
||||||
mustermann (1.0.1)
|
|
||||||
rack (2.0.4)
|
|
||||||
rack-protection (2.0.0)
|
|
||||||
rack
|
|
||||||
sinatra (2.0.0)
|
|
||||||
mustermann (~> 1.0)
|
|
||||||
rack (~> 2.0)
|
|
||||||
rack-protection (= 2.0.0)
|
|
||||||
tilt (~> 2.0)
|
|
||||||
tilt (2.0.8)
|
|
||||||
|
|
||||||
PLATFORMS
|
|
||||||
ruby
|
|
||||||
|
|
||||||
DEPENDENCIES
|
|
||||||
sinatra
|
|
||||||
|
|
@ -1,5 +0,0 @@
|
||||||
require 'sinatra'
|
|
||||||
|
|
||||||
get '/' do
|
|
||||||
'Hello world!'
|
|
||||||
end
|
|
||||||
|
|
@ -1,2 +0,0 @@
|
||||||
require './app'
|
|
||||||
run Sinatra::Application
|
|
||||||
186
test/run
186
test/run
|
|
@ -1,186 +0,0 @@
|
||||||
#!/bin/bash -x
|
|
||||||
#
|
|
||||||
# The 'run' performs a simple test that verifies that S2I image.
|
|
||||||
# The main focus here is to excersise the S2I scripts.
|
|
||||||
#
|
|
||||||
# IMAGE_NAME specifies a name of the candidate image used for testing.
|
|
||||||
# The image has to be available before this script is executed.
|
|
||||||
#
|
|
||||||
IMAGE_NAME=${IMAGE_NAME-centos/ruby-26-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 := .Config.ExposedPorts }}{{$key}}{{end}}' ${IMAGE_NAME} | sed 's/\/.*//')"
|
|
||||||
|
|
||||||
info() {
|
|
||||||
echo -e "\n\e[1m[INFO] $@...\e[0m\n"
|
|
||||||
}
|
|
||||||
|
|
||||||
image_exists() {
|
|
||||||
docker inspect $1 &>/dev/null
|
|
||||||
}
|
|
||||||
|
|
||||||
container_exists() {
|
|
||||||
image_exists $(cat $cid_file)
|
|
||||||
}
|
|
||||||
|
|
||||||
container_ip() {
|
|
||||||
docker inspect --format="{{ .NetworkSettings.IPAddress }}" $(cat $cid_file)
|
|
||||||
}
|
|
||||||
|
|
||||||
run_s2i_build() {
|
|
||||||
ct_s2i_build_as_df file://${test_dir}/${1}-test-app ${IMAGE_NAME} ${IMAGE_NAME}-testapp ${s2i_args} $(ct_build_s2i_npm_variables)
|
|
||||||
}
|
|
||||||
|
|
||||||
run_test_application() {
|
|
||||||
docker run --user=100001 --rm --cidfile=${cid_file} ${IMAGE_NAME}-testapp
|
|
||||||
}
|
|
||||||
|
|
||||||
cleanup() {
|
|
||||||
local server="$1"
|
|
||||||
info "Cleaning up the test application image $1"
|
|
||||||
if [ -f $cid_file ]; then
|
|
||||||
if container_exists; then
|
|
||||||
docker stop $(cat $cid_file)
|
|
||||||
fi
|
|
||||||
fi
|
|
||||||
if image_exists ${IMAGE_NAME}-testapp; then
|
|
||||||
docker rmi -f ${IMAGE_NAME}-testapp
|
|
||||||
fi
|
|
||||||
if [ ! -z "${server}" ]; then
|
|
||||||
rm -rf ${test_dir}/${server}-test-app/.git
|
|
||||||
fi
|
|
||||||
if [[ "${server}" == "db" ]]; then
|
|
||||||
rm -rf ${test_dir}/db-test-app
|
|
||||||
fi
|
|
||||||
}
|
|
||||||
|
|
||||||
check_result() {
|
|
||||||
local result="$1"
|
|
||||||
if [[ "$result" != "0" ]]; then
|
|
||||||
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."
|
|
||||||
|
|
@ -1,2 +0,0 @@
|
||||||
#!/bin/bash
|
|
||||||
exec pytest -vv -k test_s2i
|
|
||||||
|
|
@ -1 +0,0 @@
|
||||||
run-openshift-local-cluster
|
|
||||||
|
|
@ -1,30 +0,0 @@
|
||||||
#!/bin/bash
|
|
||||||
#
|
|
||||||
# Test the Ruby S2I image in OpenShift (remote cluster)
|
|
||||||
#
|
|
||||||
# IMAGE_NAME specifies a name of the candidate image used for testing.
|
|
||||||
# The image has to be available before this script is executed.
|
|
||||||
# VERSION specifies the major version of the Ruby runtime in format of X.Y
|
|
||||||
# OS specifies RHEL version (e.g. OS=rhel7)
|
|
||||||
#
|
|
||||||
|
|
||||||
THISDIR=$(dirname ${BASH_SOURCE[0]})
|
|
||||||
|
|
||||||
source ${THISDIR}/test-lib-ruby.sh
|
|
||||||
|
|
||||||
set -eo nounset
|
|
||||||
|
|
||||||
trap ct_os_cleanup EXIT SIGINT
|
|
||||||
|
|
||||||
ct_os_check_compulsory_vars
|
|
||||||
|
|
||||||
oc status || false "It looks like oc is not properly logged in."
|
|
||||||
|
|
||||||
export CT_SKIP_NEW_PROJECT=true
|
|
||||||
export CT_SKIP_UPLOAD_IMAGE=true
|
|
||||||
export CT_NAMESPACE=openshift
|
|
||||||
|
|
||||||
test_ruby_integration ruby ${VERSION} "${IMAGE_NAME}"
|
|
||||||
|
|
||||||
OS_TESTSUITE_RESULT=0
|
|
||||||
|
|
||||||
|
|
@ -1 +0,0 @@
|
||||||
../common/test-lib-openshift.sh
|
|
||||||
|
|
@ -1,25 +0,0 @@
|
||||||
#!/bin/bash
|
|
||||||
#
|
|
||||||
# Functions for tests for the Ruby S2I image in OpenShift.
|
|
||||||
#
|
|
||||||
# IMAGE_NAME specifies a name of the candidate image used for testing.
|
|
||||||
# The image has to be available before this script is executed.
|
|
||||||
#
|
|
||||||
|
|
||||||
THISDIR=$(dirname ${BASH_SOURCE[0]})
|
|
||||||
|
|
||||||
source ${THISDIR}/test-lib.sh
|
|
||||||
source ${THISDIR}/test-lib-openshift.sh
|
|
||||||
|
|
||||||
function test_ruby_integration() {
|
|
||||||
local image_name=$1
|
|
||||||
local version=$2
|
|
||||||
local import_image=${3:-}
|
|
||||||
VERSION=$version ct_os_test_s2i_app "${image_name}" \
|
|
||||||
"https://github.com/sclorg/s2i-ruby-container.git" \
|
|
||||||
${version}/test/puma-test-app \
|
|
||||||
".*" \
|
|
||||||
8080 http 200 "" \
|
|
||||||
"${import_image}"
|
|
||||||
}
|
|
||||||
|
|
||||||
602
test/test-lib.sh
602
test/test-lib.sh
|
|
@ -1,602 +0,0 @@
|
||||||
#
|
|
||||||
# Test a container image.
|
|
||||||
#
|
|
||||||
# Always use sourced from a specific container testfile
|
|
||||||
#
|
|
||||||
# reguires definition of CID_FILE_DIR
|
|
||||||
# CID_FILE_DIR=$(mktemp --suffix=<container>_test_cidfiles -d)
|
|
||||||
# reguires definition of TEST_LIST
|
|
||||||
# TEST_LIST="\
|
|
||||||
# ctest_container_creation
|
|
||||||
# ctest_doc_content"
|
|
||||||
|
|
||||||
# Container CI tests
|
|
||||||
# abbreviated as "ct"
|
|
||||||
|
|
||||||
# may be redefined in the specific container testfile
|
|
||||||
EXPECTED_EXIT_CODE=0
|
|
||||||
|
|
||||||
# ct_cleanup
|
|
||||||
# --------------------
|
|
||||||
# Cleans up containers used during tests. Stops and removes all containers
|
|
||||||
# referenced by cid_files in CID_FILE_DIR. Dumps logs if a container exited
|
|
||||||
# unexpectedly. Removes the cid_files and CID_FILE_DIR as well.
|
|
||||||
# Uses: $CID_FILE_DIR - path to directory containing cid_files
|
|
||||||
# Uses: $EXPECTED_EXIT_CODE - expected container exit code
|
|
||||||
function ct_cleanup() {
|
|
||||||
for cid_file in $CID_FILE_DIR/* ; do
|
|
||||||
local container=$(cat $cid_file)
|
|
||||||
|
|
||||||
: "Stopping and removing container $container..."
|
|
||||||
docker stop $container
|
|
||||||
exit_status=$(docker inspect -f '{{.State.ExitCode}}' $container)
|
|
||||||
if [ "$exit_status" != "$EXPECTED_EXIT_CODE" ]; then
|
|
||||||
: "Dumping logs for $container"
|
|
||||||
docker logs $container
|
|
||||||
fi
|
|
||||||
docker rm -v $container
|
|
||||||
rm $cid_file
|
|
||||||
done
|
|
||||||
rmdir $CID_FILE_DIR
|
|
||||||
: "Done."
|
|
||||||
}
|
|
||||||
|
|
||||||
# ct_enable_cleanup
|
|
||||||
# --------------------
|
|
||||||
# Enables automatic container cleanup after tests.
|
|
||||||
function ct_enable_cleanup() {
|
|
||||||
trap ct_cleanup EXIT SIGINT
|
|
||||||
}
|
|
||||||
|
|
||||||
# ct_get_cid [name]
|
|
||||||
# --------------------
|
|
||||||
# Prints container id from cid_file based on the name of the file.
|
|
||||||
# Argument: name - name of cid_file where the container id will be stored
|
|
||||||
# Uses: $CID_FILE_DIR - path to directory containing cid_files
|
|
||||||
function ct_get_cid() {
|
|
||||||
local name="$1" ; shift || return 1
|
|
||||||
echo $(cat "$CID_FILE_DIR/$name")
|
|
||||||
}
|
|
||||||
|
|
||||||
# ct_get_cip [id]
|
|
||||||
# --------------------
|
|
||||||
# Prints container ip address based on the container id.
|
|
||||||
# Argument: id - container id
|
|
||||||
function ct_get_cip() {
|
|
||||||
local id="$1" ; shift
|
|
||||||
docker inspect --format='{{.NetworkSettings.IPAddress}}' $(ct_get_cid "$id")
|
|
||||||
}
|
|
||||||
|
|
||||||
# ct_wait_for_cid [cid_file]
|
|
||||||
# --------------------
|
|
||||||
# Holds the execution until the cid_file is created. Usually run after container
|
|
||||||
# creation.
|
|
||||||
# Argument: cid_file - name of the cid_file that should be created
|
|
||||||
function ct_wait_for_cid() {
|
|
||||||
local cid_file=$1
|
|
||||||
local max_attempts=10
|
|
||||||
local sleep_time=1
|
|
||||||
local attempt=1
|
|
||||||
local result=1
|
|
||||||
while [ $attempt -le $max_attempts ]; do
|
|
||||||
[ -f $cid_file ] && [ -s $cid_file ] && return 0
|
|
||||||
: "Waiting for container start..."
|
|
||||||
attempt=$(( $attempt + 1 ))
|
|
||||||
sleep $sleep_time
|
|
||||||
done
|
|
||||||
return 1
|
|
||||||
}
|
|
||||||
|
|
||||||
# ct_assert_container_creation_fails [container_args]
|
|
||||||
# --------------------
|
|
||||||
# The invocation of docker run should fail based on invalid container_args
|
|
||||||
# passed to the function. Returns 0 when container fails to start properly.
|
|
||||||
# Argument: container_args - all arguments are passed directly to dokcer run
|
|
||||||
# Uses: $CID_FILE_DIR - path to directory containing cid_files
|
|
||||||
function ct_assert_container_creation_fails() {
|
|
||||||
local ret=0
|
|
||||||
local max_attempts=10
|
|
||||||
local attempt=1
|
|
||||||
local cid_file=assert
|
|
||||||
set +e
|
|
||||||
local old_container_args="${CONTAINER_ARGS-}"
|
|
||||||
CONTAINER_ARGS="$@"
|
|
||||||
ct_create_container $cid_file
|
|
||||||
if [ $? -eq 0 ]; then
|
|
||||||
local cid=$(ct_get_cid $cid_file)
|
|
||||||
|
|
||||||
while [ "$(docker inspect -f '{{.State.Running}}' $cid)" == "true" ] ; do
|
|
||||||
sleep 2
|
|
||||||
attempt=$(( $attempt + 1 ))
|
|
||||||
if [ $attempt -gt $max_attempts ]; then
|
|
||||||
docker stop $cid
|
|
||||||
ret=1
|
|
||||||
break
|
|
||||||
fi
|
|
||||||
done
|
|
||||||
exit_status=$(docker inspect -f '{{.State.ExitCode}}' $cid)
|
|
||||||
if [ "$exit_status" == "0" ]; then
|
|
||||||
ret=1
|
|
||||||
fi
|
|
||||||
docker rm -v $cid
|
|
||||||
rm $CID_FILE_DIR/$cid_file
|
|
||||||
fi
|
|
||||||
[ ! -z $old_container_args ] && CONTAINER_ARGS="$old_container_args"
|
|
||||||
set -e
|
|
||||||
return $ret
|
|
||||||
}
|
|
||||||
|
|
||||||
# ct_create_container [name, command]
|
|
||||||
# --------------------
|
|
||||||
# Creates a container using the IMAGE_NAME and CONTAINER_ARGS variables. Also
|
|
||||||
# stores the container id to a cid_file located in the CID_FILE_DIR, and waits
|
|
||||||
# for the creation of the file.
|
|
||||||
# Argument: name - name of cid_file where the container id will be stored
|
|
||||||
# Argument: command - optional command to be executed in the container
|
|
||||||
# Uses: $CID_FILE_DIR - path to directory containing cid_files
|
|
||||||
# Uses: $CONTAINER_ARGS - optional arguments passed directly to docker run
|
|
||||||
# Uses: $IMAGE_NAME - name of the image being tested
|
|
||||||
function ct_create_container() {
|
|
||||||
local cid_file="$CID_FILE_DIR/$1" ; shift
|
|
||||||
# create container with a cidfile in a directory for cleanup
|
|
||||||
docker run --cidfile="$cid_file" -d ${CONTAINER_ARGS:-} $IMAGE_NAME "$@"
|
|
||||||
ct_wait_for_cid $cid_file || return 1
|
|
||||||
: "Created container $(cat $cid_file)"
|
|
||||||
}
|
|
||||||
|
|
||||||
# ct_scl_usage_old [name, command, expected]
|
|
||||||
# --------------------
|
|
||||||
# Tests three ways of running the SCL, by looking for an expected string
|
|
||||||
# in the output of the command
|
|
||||||
# Argument: name - name of cid_file where the container id will be stored
|
|
||||||
# Argument: command - executed inside the container
|
|
||||||
# Argument: expected - string that is expected to be in the command output
|
|
||||||
# Uses: $CID_FILE_DIR - path to directory containing cid_files
|
|
||||||
# Uses: $IMAGE_NAME - name of the image being tested
|
|
||||||
function ct_scl_usage_old() {
|
|
||||||
local name="$1"
|
|
||||||
local command="$2"
|
|
||||||
local expected="$3"
|
|
||||||
local out=""
|
|
||||||
: " Testing the image SCL enable"
|
|
||||||
out=$(docker run --rm ${IMAGE_NAME} /bin/bash -c "${command}")
|
|
||||||
if ! echo "${out}" | grep -q "${expected}"; then
|
|
||||||
echo "ERROR[/bin/bash -c "${command}"] Expected '${expected}', got '${out}'" >&2
|
|
||||||
return 1
|
|
||||||
fi
|
|
||||||
out=$(docker exec $(ct_get_cid $name) /bin/bash -c "${command}" 2>&1)
|
|
||||||
if ! echo "${out}" | grep -q "${expected}"; then
|
|
||||||
echo "ERROR[exec /bin/bash -c "${command}"] Expected '${expected}', got '${out}'" >&2
|
|
||||||
return 1
|
|
||||||
fi
|
|
||||||
out=$(docker exec $(ct_get_cid $name) /bin/sh -ic "${command}" 2>&1)
|
|
||||||
if ! echo "${out}" | grep -q "${expected}"; then
|
|
||||||
echo "ERROR[exec /bin/sh -ic "${command}"] Expected '${expected}', got '${out}'" >&2
|
|
||||||
return 1
|
|
||||||
fi
|
|
||||||
}
|
|
||||||
|
|
||||||
# ct_doc_content_old [strings]
|
|
||||||
# --------------------
|
|
||||||
# Looks for occurence of stirngs in the documentation files and checks
|
|
||||||
# the format of the files. Files examined: help.1
|
|
||||||
# Argument: strings - strings expected to appear in the documentation
|
|
||||||
# Uses: $IMAGE_NAME - name of the image being tested
|
|
||||||
function ct_doc_content_old() {
|
|
||||||
local tmpdir=$(mktemp -d)
|
|
||||||
local f
|
|
||||||
: " Testing documentation in the container image"
|
|
||||||
# Extract the help files from the container
|
|
||||||
for f in help.1 ; do
|
|
||||||
docker run --rm ${IMAGE_NAME} /bin/bash -c "cat /${f}" >${tmpdir}/$(basename ${f})
|
|
||||||
# Check whether the files contain some important information
|
|
||||||
for term in $@ ; do
|
|
||||||
if ! cat ${tmpdir}/$(basename ${f}) | grep -F -q -e "${term}" ; then
|
|
||||||
echo "ERROR: File /${f} does not include '${term}'." >&2
|
|
||||||
return 1
|
|
||||||
fi
|
|
||||||
done
|
|
||||||
# Check whether the files use the correct format
|
|
||||||
for term in TH PP SH ; do
|
|
||||||
if ! grep -q "^\.${term}" ${tmpdir}/help.1 ; then
|
|
||||||
echo "ERROR: /help.1 is probably not in troff or groff format, since '${term}' is missing." >&2
|
|
||||||
return 1
|
|
||||||
fi
|
|
||||||
done
|
|
||||||
done
|
|
||||||
: " Success!"
|
|
||||||
}
|
|
||||||
|
|
||||||
# full_ca_file_path
|
|
||||||
# Return string for full path to CA file
|
|
||||||
function full_ca_file_path()
|
|
||||||
{
|
|
||||||
echo "/etc/pki/ca-trust/source/anchors/RH-IT-Root-CA.crt"
|
|
||||||
}
|
|
||||||
# ct_mount_ca_file
|
|
||||||
# ------------------
|
|
||||||
# Check if /etc/pki/certs/RH-IT-Root-CA.crt file exists
|
|
||||||
# return mount string for containers or empty string
|
|
||||||
function ct_mount_ca_file()
|
|
||||||
{
|
|
||||||
# mount CA file only if NPM_REGISTRY variable is present.
|
|
||||||
local mount_parameter=""
|
|
||||||
if [ -n "$NPM_REGISTRY" ] && [ -f "$(full_ca_file_path)" ]; then
|
|
||||||
mount_parameter="-v $(full_ca_file_path):$(full_ca_file_path):Z"
|
|
||||||
fi
|
|
||||||
echo "$mount_parameter"
|
|
||||||
}
|
|
||||||
|
|
||||||
# ct_build_s2i_npm_variables URL_TO_NPM_JS_SERVER
|
|
||||||
# ------------------------------------------
|
|
||||||
# Function returns -e NPM_MIRROR and -v MOUNT_POINT_FOR_CAFILE
|
|
||||||
# or empty string
|
|
||||||
function ct_build_s2i_npm_variables()
|
|
||||||
{
|
|
||||||
npm_variables=""
|
|
||||||
if [ -n "$NPM_REGISTRY" ] && [ -f "$(full_ca_file_path)" ]; then
|
|
||||||
npm_variables="-e NPM_MIRROR=$NPM_REGISTRY $(ct_mount_ca_file)"
|
|
||||||
fi
|
|
||||||
echo "$npm_variables"
|
|
||||||
}
|
|
||||||
|
|
||||||
# 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"
|
|
||||||
cid_file="${tmpdir}/cid"
|
|
||||||
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 -d $(ct_mount_ca_file) --rm --cidfile="$cid_file" ${IMAGE_NAME}-testapp
|
|
||||||
|
|
||||||
# Wait for the container to write it's CID file
|
|
||||||
ct_wait_for_cid "$cid_file" || return 1
|
|
||||||
|
|
||||||
docker exec $(cat "$cid_file") /bin/bash -c "npm --verbose install jquery && test -f node_modules/jquery/src/jquery.js" >${tmpdir}/jquery 2>&1
|
|
||||||
|
|
||||||
if [ $? -ne 0 ] ; then
|
|
||||||
echo "ERROR: npm could not install jquery inside the image ${IMAGE_NAME}." >&2
|
|
||||||
return 1
|
|
||||||
fi
|
|
||||||
|
|
||||||
if [ -n "$NPM_REGISTRY" ] && [ -f "$(full_ca_file_path)" ]; then
|
|
||||||
if ! grep -qo "$NPM_REGISTRY" "${tmpdir}/jquery"; then
|
|
||||||
echo "ERROR: Internal repository is NOT set. Even it is requested."
|
|
||||||
return 1
|
|
||||||
fi
|
|
||||||
fi
|
|
||||||
|
|
||||||
if [ -f "$cid_file" ]; then
|
|
||||||
docker stop $(cat "$cid_file")
|
|
||||||
rm "$cid_file"
|
|
||||||
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
|
|
||||||
rhel*)
|
|
||||||
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.
|
|
||||||
# Only used to check for pull-policy=never and environment variable definitions.
|
|
||||||
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=
|
|
||||||
local incremental=false
|
|
||||||
local mount_options=""
|
|
||||||
|
|
||||||
# Run the entire thing inside a subshell so that we do not leak shell options outside of the function
|
|
||||||
(
|
|
||||||
# Error out if any part of the build fails
|
|
||||||
set -e
|
|
||||||
|
|
||||||
# Use /tmp to not pollute cwd
|
|
||||||
tmpdir=$(mktemp -d)
|
|
||||||
df_name=$(mktemp -p "$tmpdir" Dockerfile.XXXX)
|
|
||||||
cd "$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=$(docker inspect -f "{{.Config.User}}" "$src_image")
|
|
||||||
# Default to root if no user is set by the image
|
|
||||||
user=${user:-0}
|
|
||||||
# run the user through the image in case it is non-numeric or does not exist
|
|
||||||
# NOTE: The '-eq' test is used to check if $user is numeric as it will fail if $user is not an integer
|
|
||||||
if ! [ "$user" -eq "$user" ] 2>/dev/null && ! user_id=$(docker run --rm "$src_image" bash -c "id -u $user 2>/dev/null"); then
|
|
||||||
echo "ERROR: id of user $user not found inside image $src_image."
|
|
||||||
echo "Terminating s2i build."
|
|
||||||
return 1
|
|
||||||
else
|
|
||||||
user_id=${user_id:-$user}
|
|
||||||
fi
|
|
||||||
echo "$s2i_args" | grep -q "\-\-incremental" && incremental=true
|
|
||||||
if $incremental; then
|
|
||||||
inc_tmp=$(mktemp -d --tmpdir incremental.XXXX)
|
|
||||||
setfacl -m "u:$user_id:rwx" "$inc_tmp"
|
|
||||||
# Check if the image exists, build should fail (for testing use case) if it does not
|
|
||||||
docker images "$dst_image" &>/dev/null || (echo "Image $dst_image not found."; false)
|
|
||||||
# Run the original image with a mounted in volume and get the artifacts out of it
|
|
||||||
cmd="if [ -s /usr/libexec/s2i/save-artifacts ]; then /usr/libexec/s2i/save-artifacts > \"$inc_tmp/artifacts.tar\"; else touch \"$inc_tmp/artifacts.tar\"; fi"
|
|
||||||
docker run --rm -v "$inc_tmp:$inc_tmp:Z" "$dst_image" bash -c "$cmd"
|
|
||||||
# Move the created content into the $tmpdir for the build to pick it up
|
|
||||||
mv "$inc_tmp/artifacts.tar" "$tmpdir/"
|
|
||||||
fi
|
|
||||||
# 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
|
|
||||||
#FIXME: Some commands could be combined into a single layer but not sure if worth the trouble for testing purposes
|
|
||||||
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 inside .s2i/ folder
|
|
||||||
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
|
|
||||||
# Filter out env var definitions from $s2i_args and create Dockerfile ENV commands out of them
|
|
||||||
echo "$s2i_args" | grep -o -e '\(-e\|--env\)[[:space:]=]\S*=\S*' | sed -e 's/-e /ENV /' -e 's/--env[ =]/ENV /' >>"$df_name"
|
|
||||||
# Check if CA autority is present on host and add it into Dockerfile
|
|
||||||
[ -f "$(full_ca_file_path)" ] && echo "RUN cd /etc/pki/ca-trust/source/anchors && update-ca-trust extract" >>"$df_name"
|
|
||||||
|
|
||||||
# Add in artifacts if doing an incremental build
|
|
||||||
if $incremental; then
|
|
||||||
echo "RUN mkdir /tmp/artifacts" >>"$df_name"
|
|
||||||
echo "ADD artifacts.tar /tmp/artifacts" >>"$df_name"
|
|
||||||
echo "RUN chown -R $user_id:0 /tmp/artifacts" >>"$df_name"
|
|
||||||
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
|
|
||||||
|
|
||||||
# Check if -v parameter is present in s2i_args and add it into docker build command
|
|
||||||
mount_options=$(echo "$s2i_args" | grep -o -e '\(-v\)[[:space:]]\.*\S*' || true)
|
|
||||||
|
|
||||||
# Run the build and tag the result
|
|
||||||
docker build $mount_options -f "$df_name" --no-cache=true -t "$dst_image" .
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
# vim: set tabstop=2:shiftwidth=2:expandtab:
|
|
||||||
|
|
@ -1,83 +0,0 @@
|
||||||
#!/usr/bin/python3
|
|
||||||
import logging
|
|
||||||
import os
|
|
||||||
import time
|
|
||||||
|
|
||||||
from conu import DockerBackend, S2IDockerImage, Probe, DockerRunBuilder
|
|
||||||
|
|
||||||
import pytest
|
|
||||||
|
|
||||||
|
|
||||||
image_name = os.environ.get("IMAGE_NAME", "ruby")
|
|
||||||
test_dir = os.path.abspath(os.path.dirname(__file__))
|
|
||||||
puma_app_path = os.path.join(test_dir, "puma-test-app")
|
|
||||||
rack_app_path = os.path.join(test_dir, "rack-test-app")
|
|
||||||
app_paths = [
|
|
||||||
puma_app_path,
|
|
||||||
rack_app_path
|
|
||||||
]
|
|
||||||
|
|
||||||
|
|
||||||
backend = DockerBackend(logging_level=logging.DEBUG)
|
|
||||||
|
|
||||||
|
|
||||||
@pytest.fixture(scope="module", params=app_paths)
|
|
||||||
def app(request):
|
|
||||||
i = S2IDockerImage(image_name)
|
|
||||||
app_name = os.path.basename(request.param)
|
|
||||||
app = i.extend(request.param, app_name)
|
|
||||||
yield app
|
|
||||||
pass
|
|
||||||
app.rmi()
|
|
||||||
|
|
||||||
|
|
||||||
class TestSuite:
|
|
||||||
def test_s2i_apps(self, app):
|
|
||||||
c = app.run_via_binary()
|
|
||||||
try:
|
|
||||||
c.wait_for_port(8080)
|
|
||||||
assert c.is_port_open(8080)
|
|
||||||
response = c.http_request("/", port="8080")
|
|
||||||
assert response.ok
|
|
||||||
output = c.execute(["bash", "-c", "ruby --version"])[0]
|
|
||||||
expected = "ruby %s." % os.environ["VERSION"]
|
|
||||||
assert expected in output.decode("utf-8")
|
|
||||||
finally:
|
|
||||||
c.stop()
|
|
||||||
c.wait()
|
|
||||||
# debugging
|
|
||||||
print(list(c.logs()))
|
|
||||||
c.delete()
|
|
||||||
|
|
||||||
def test_invoking_container(self):
|
|
||||||
image = backend.ImageClass(image_name)
|
|
||||||
c = image.run_via_binary(DockerRunBuilder(command=["bash", "-c", "ruby --version"]))
|
|
||||||
try:
|
|
||||||
c.wait()
|
|
||||||
logs = list(c.logs())[0].decode("utf-8")
|
|
||||||
finally:
|
|
||||||
c.stop()
|
|
||||||
c.wait()
|
|
||||||
c.delete()
|
|
||||||
assert "ruby " in logs
|
|
||||||
if os.environ.get("VERSION", None):
|
|
||||||
assert os.environ["VERSION"] in logs
|
|
||||||
|
|
||||||
def test_usage(self):
|
|
||||||
i = S2IDockerImage(image_name)
|
|
||||||
c = i.run_via_binary()
|
|
||||||
|
|
||||||
def logs_received():
|
|
||||||
return len(list(c.logs())) > 0
|
|
||||||
|
|
||||||
try:
|
|
||||||
c.wait()
|
|
||||||
# even after waiting there is still a race in journal logging driver
|
|
||||||
Probe(timeout=10, pause=0.05, count=20, fnc=logs_received).run()
|
|
||||||
logs = [x.decode("utf-8") for x in c.logs()]
|
|
||||||
logs = "\n".join(logs).strip()
|
|
||||||
usage = i.usage()
|
|
||||||
# FIXME: workaround: `docker logs` can't handle logs like these: '\n\n\n'
|
|
||||||
assert logs.replace("\n", "") == usage.replace("\n", "")
|
|
||||||
finally:
|
|
||||||
c.delete()
|
|
||||||
Loading…
Add table
Add a link
Reference in a new issue