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

container sources not used for building fedora containers anymore

Browse source
This commit is contained in:
Honza Horak 2025-07-08 17:39:15 +02:00
commit ccaeea651f
52 changed files with 1 additions and 4330 deletions
Download patch file Download diff file Expand all files Collapse all files

0
.gitignore vendored
View file

1
8.0
View file

@ -1 +0,0 @@
.

78
Dockerfile
View file

@ -1,78 +0,0 @@
FROM registry.fedoraproject.org/f32/s2i-core:latest
# MySQL image for OpenShift.
#
# Volumes:
# * /var/lib/mysql/data - Datastore for MySQL
# Environment:
# * $MYSQL_USER - Database user name
# * $MYSQL_PASSWORD - User's password
# * $MYSQL_DATABASE - Name of the database to create
# * $MYSQL_ROOT_PASSWORD (Optional) - Password for the 'root' MySQL account
ENV MYSQL_VERSION=8.0 \
APP_DATA=/opt/app-root/src \
HOME=/var/lib/mysql
ENV SUMMARY="MySQL $MYSQL_VERSION SQL database server" \
DESCRIPTION="MySQL is a multi-user, multi-threaded SQL database server. The container \
image provides a containerized packaging of the MySQL mysqld daemon and client application. \
The mysqld server daemon accepts connections from clients and provides access to content from \
MySQL databases on behalf of the clients."
ENV NAME=mysql \
VERSION=0
LABEL summary="$SUMMARY" \
description="$DESCRIPTION" \
io.k8s.description="$DESCRIPTION" \
io.k8s.display-name="MySQL $MYSQL_VERSION" \
io.openshift.expose-services="3306:mysql" \
io.openshift.tags="database,mysql,mysql80,rh-mysql80" \
com.redhat.component="$NAME" \
name="$FGC/$NAME" \
version="$MYSQL_VERSION" \
release="1.container" \
usage="docker run -d -e MYSQL_USER=user -e MYSQL_PASSWORD=pass -e MYSQL_DATABASE=db -p 3306:3306 $FGC/$NAME" \
maintainer="SoftwareCollections.org <sclorg@redhat.com>"
EXPOSE 3306
# On Fedora, we fake missing python binary. In case user installs the python2
# in the container, this hack will be removed by installing /usr/bin/python from RPM.
RUN ln -s /usr/bin/python3 /usr/bin/python
# This image must forever use UID 27 for mysql user so our volumes are
# safe in the future. This should *never* change, the last test is there
# to make sure of that.
RUN INSTALL_PKGS="rsync tar gettext hostname bind-utils groff-base community-mysql-server policycoreutils" && \
yum install -y --setopt=tsflags=nodocs $INSTALL_PKGS && \
rpm -V $INSTALL_PKGS && \
yum -y clean all --enablerepo='*' && \
mkdir -p /var/lib/mysql/data && chown -R mysql.0 /var/lib/mysql && \
test "$(id mysql)" = "uid=27(mysql) gid=27(mysql) groups=27(mysql)"
# Get prefix path and path to scripts rather than hard-code them in scripts
ENV CONTAINER_SCRIPTS_PATH=/usr/share/container-scripts/mysql \
MYSQL_PREFIX=/usr
COPY 8.0/root-common /
COPY 8.0/s2i-common/bin/ $STI_SCRIPTS_PATH
COPY 8.0/root /
# this is needed due to issues with squash
# when this directory gets rm'd by the container-setup
# script.
# Also reset permissions of filesystem to default values
RUN rm -rf /etc/my.cnf.d/* && \
/usr/libexec/container-setup && \
rpm-file-permissions
# Not using VOLUME statement since it's not working in OpenShift Online:
# https://github.com/sclorg/httpd-container/issues/30
# VOLUME ["/var/lib/mysql/data"]
USER 27
ENTRYPOINT ["container-entrypoint"]
CMD ["run-mysqld"]

1
README.md
View file

@ -1 +0,0 @@
root/usr/share/container-scripts/mysql/README.md

1
dead.package Normal file
View file

@ -0,0 +1 @@
container sources not used for building fedora containers anymore

1
help.md
View file

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

9
root-common/etc/my.cnf
View file

@ -1,9 +0,0 @@
[mysqld]
# Disabling symbolic-links is recommended to prevent assorted security risks
symbolic-links = 0
# http://www.percona.com/blog/2008/05/31/dns-achilles-heel-mysql-installation/
skip_name_resolve
!includedir /etc/my.cnf.d

2
root-common/usr/bin/container-entrypoint
View file

@ -1,2 +0,0 @@
#!/bin/bash
exec "$@"

1
root-common/usr/bin/mysqld-master
View file

@ -1 +0,0 @@
run-mysqld-master

1
root-common/usr/bin/mysqld-slave
View file

@ -1 +0,0 @@
run-mysqld-slave

39
root-common/usr/bin/run-mysqld
View file

@ -1,39 +0,0 @@
#!/bin/bash
export_vars=$(cgroup-limits); export $export_vars
source ${CONTAINER_SCRIPTS_PATH}/common.sh
set -eu
if [[ -v DEBUG_IGNORE_SCRIPT_FAILURES ]]; then
set +e
fi
export_setting_variables
log_volume_info $MYSQL_DATADIR
# pre-init files
process_extending_files ${APP_DATA}/mysql-pre-init/ ${CONTAINER_SCRIPTS_PATH}/pre-init/
if [ ! -d "$MYSQL_DATADIR/mysql" ]; then
initialize_database "$@"
else
start_local_mysql "$@"
fi
# set mysql_flags and admin_flagsadmin_flags properly
if [ -z "${MYSQL_ROOT_PASSWORD:-}" ] || is_allowing_connection_with_empty_password; then
mysql_flags="-u root --socket=$MYSQL_LOCAL_SOCKET"
else
mysql_flags="-u root --socket=$MYSQL_LOCAL_SOCKET -p${MYSQL_ROOT_PASSWORD}"
fi
admin_flags="--defaults-file=$MYSQL_DEFAULTS_FILE $mysql_flags"
# init files
process_extending_files ${APP_DATA}/mysql-init/ ${CONTAINER_SCRIPTS_PATH}/init/
# Restart the MySQL server with public IP bindings
shutdown_local_mysql
unset_env_vars
log_volume_info $MYSQL_DATADIR
log_info 'Running final exec -- Only MySQL server logs after this point'
exec ${MYSQL_PREFIX}/libexec/mysqld --defaults-file=$MYSQL_DEFAULTS_FILE "$@" 2>&1

50
root-common/usr/bin/run-mysqld-master
View file

@ -1,50 +0,0 @@
#!/bin/bash
#
# This is an entrypoint that runs the MySQL server in the 'master' mode.
#
export_vars=$(cgroup-limits); export $export_vars
source ${CONTAINER_SCRIPTS_PATH}/common.sh
set -eu
if [[ -v DEBUG_IGNORE_SCRIPT_FAILURES ]]; then
set +e
fi
export_setting_variables
log_volume_info $MYSQL_DATADIR
export MYSQL_RUNNING_AS_MASTER=1
# The 'server-id' for master needs to be constant
export MYSQL_SERVER_ID=1
log_info "The 'master' server-id is ${MYSQL_SERVER_ID}"
# pre-init files
process_extending_files ${APP_DATA}/mysql-pre-init/ ${CONTAINER_SCRIPTS_PATH}/pre-init/
if [ ! -d "$MYSQL_DATADIR/mysql" ]; then
initialize_database "$@"
else
start_local_mysql "$@"
fi
log_info 'Setting passwords ...'
[ -f ${CONTAINER_SCRIPTS_PATH}/passwd-change.sh ] && source ${CONTAINER_SCRIPTS_PATH}/passwd-change.sh
# Setup the 'master' replication on the MySQL server
mysql $mysql_flags <<EOSQL
CREATE USER IF NOT EXISTS '${MYSQL_MASTER_USER}'@'%' IDENTIFIED BY '${MYSQL_MASTER_PASSWORD}';
GRANT REPLICATION SLAVE ON *.* TO '${MYSQL_MASTER_USER}'@'%';
FLUSH PRIVILEGES;
EOSQL
# init files
process_extending_files ${APP_DATA}/mysql-init/ ${CONTAINER_SCRIPTS_PATH}/init/
# Restart the MySQL server with public IP bindings
shutdown_local_mysql
unset_env_vars
log_volume_info $MYSQL_DATADIR
log_info 'Running final exec -- Only MySQL server logs after this point'
exec ${MYSQL_PREFIX}/libexec/mysqld --defaults-file=$MYSQL_DEFAULTS_FILE "$@" 2>&1

47
root-common/usr/bin/run-mysqld-slave
View file

@ -1,47 +0,0 @@
#!/bin/bash
#
# This is an entrypoint that runs the MySQL server in the 'slave' mode.
#
export_vars=$(cgroup-limits); export $export_vars
source ${CONTAINER_SCRIPTS_PATH}/common.sh
set -eu
if [[ -v DEBUG_IGNORE_SCRIPT_FAILURES ]]; then
set +e
fi
export_setting_variables
log_volume_info $MYSQL_DATADIR
export MYSQL_RUNNING_AS_SLAVE=1
# Generate the unique 'server-id' for this master
export MYSQL_SERVER_ID=$(server_id)
log_info "The 'slave' server-id is ${MYSQL_SERVER_ID}"
# pre-init files
process_extending_files ${APP_DATA}/mysql-pre-init/ ${CONTAINER_SCRIPTS_PATH}/pre-init/
if [ ! -e "${MYSQL_DATADIR}/mysql" ]; then
# Initialize MySQL database and wait for the MySQL master to accept
# connections.
initialize_database "$@"
wait_for_mysql_master
mysql $mysql_flags <<EOSQL
CHANGE MASTER TO MASTER_HOST='${MYSQL_MASTER_SERVICE_NAME}',MASTER_USER='${MYSQL_MASTER_USER}', MASTER_PASSWORD='${MYSQL_MASTER_PASSWORD}', MASTER_AUTO_POSITION = 1;
EOSQL
# init files
process_extending_files ${APP_DATA}/mysql-init/ ${CONTAINER_SCRIPTS_PATH}/init/
# Restart the MySQL server with public IP bindings
shutdown_local_mysql
fi
unset_env_vars
log_volume_info $MYSQL_DATADIR
log_info 'Running final exec -- Only MySQL server logs after this point'
exec ${MYSQL_PREFIX}/libexec/mysqld --defaults-file=$MYSQL_DEFAULTS_FILE \
--report-host=$(hostname -I) "$@" 2>&1

4
root-common/usr/bin/usage
View file

@ -1,4 +0,0 @@
#!/bin/bash
cat /usr/share/container-scripts/mysql/README.md

69
root-common/usr/libexec/container-setup
View file

@ -1,69 +0,0 @@
#!/bin/bash
source ${CONTAINER_SCRIPTS_PATH}/common.sh
# This function returns all config files that daemon uses and their path
# includes /opt. It is used to get correct path to the config file.
mysql_get_config_files_scl() {
scl enable ${ENABLED_COLLECTIONS} -- my_print_defaults --help --verbose | \
grep --after=1 '^Default options' | \
tail -n 1 | \
grep -o '[^ ]*opt[^ ]*my.cnf'
}
# This function picks the main config file that deamon uses and we ship in rpm
mysql_get_correct_config() {
# we use the same config in non-SCL packages, not necessary to guess
[ -z "${ENABLED_COLLECTIONS}" ] && echo -n "/etc/my.cnf" && return
# from all config files read by daemon, pick the first that exists
for f in `mysql_get_config_files_scl` ; do
[ -f "$f" ] && echo "$f"
done | head -n 1
}
export MYSQL_CONFIG_FILE=$(mysql_get_correct_config)
[ -z "$MYSQL_CONFIG_FILE" ] && echo "MYSQL_CONFIG_FILE is empty" && exit 1
unset -f mysql_get_correct_config mysql_get_config_files_scl
# we provide own config files for the container, so clean what rpm ships here
mkdir -p ${MYSQL_CONFIG_FILE}.d
rm -f ${MYSQL_CONFIG_FILE}.d/*
# we may add options during service init, so we need to have this dir writable by daemon user
chown -R mysql:0 ${MYSQL_CONFIG_FILE}.d ${MYSQL_CONFIG_FILE}
restorecon -R ${MYSQL_CONFIG_FILE}.d ${MYSQL_CONFIG_FILE}
# API of the container are standard paths /etc/my.cnf and /etc/my.cnf.d
# we already include own /etc/my.cnf for container, but for cases the
# actually used config file is not on standard path /etc/my.cnf, we
# need to move it to the location daemon expects it and create symlinks
if [ "$MYSQL_CONFIG_FILE" != "/etc/my.cnf" ] ; then
rm -rf /etc/my.cnf.d
mv /etc/my.cnf ${MYSQL_CONFIG_FILE}
ln -s ${MYSQL_CONFIG_FILE} /etc/my.cnf
ln -s ${MYSQL_CONFIG_FILE}.d /etc/my.cnf.d
fi
# some config options are only valid for particular versions
if [ "`version2number $MYSQL_VERSION`" -ge "800" ] ; then
rm -f "${CONTAINER_SCRIPTS_PATH}/cnf/10-mysql57.cnf"
fi
# setup directory for data
mkdir -p /var/lib/mysql/data
chown -R mysql:0 /var/lib/mysql
restorecon -R /var/lib/mysql
# remove linux capability of the daemon, since it does not work in the container
setcap -r ${MYSQL_PREFIX}/libexec/mysqld
# Loosen permission bits for group to avoid problems running container with
# arbitrary UID
# When only specifying user, group is 0, that's why /var/lib/mysql must have
# owner mysql.0; that allows to avoid a+rwx for this dir
/usr/libexec/fix-permissions /var/lib/mysql ${MYSQL_CONFIG_FILE}.d ${APP_DATA}/..
usermod -a -G root mysql

6
root-common/usr/libexec/fix-permissions
View file

@ -1,6 +0,0 @@
#!/bin/sh
# Fix permissions on the given directory to allow group read/write of
# regular files and execute of directories.
find $@ -exec chown mysql:0 {} \;
find $@ -exec chmod g+rw {} \;
find $@ -type d -exec chmod g+x {} +

5
root-common/usr/share/container-scripts/mysql/cnf/10-mysql57.cnf
View file

@ -1,5 +0,0 @@
[mysqld]
# http://www.chriscalender.com/ignoring-the-lostfound-directory-in-your-datadir/
ignore-db-dir=lost+found

19
root-common/usr/share/container-scripts/mysql/cnf/20-default-authentication-plugin.cnf
View file

@ -1,19 +0,0 @@
# MySQL 8.0.4 introduced 'caching_sha2_password' as its default authentication plugin.
# It is faster and provides better security then the previous default authentication plugin.
#
# However, not all software implements this algorithm, and client applications might report
# issue like "The server requested authentication method"
#
# The plugin can be changed by setting default_authentication_plugin variable.
#
# The default_authentication_plugin options accepts these values:
# caching_sha2_password, mysql_native_password
#
# To change the behaviour back to the same behavior as MySQL 5.7 had, set the
# default_authentication_plugin variable to mysql_native_password.
#
# Upstream doc at https://dev.mysql.com/doc/refman/8.0/en/caching-sha2-pluggable-authentication.html
[mysqld]
default_authentication_plugin=${MYSQL_DEFAULT_AUTHENTICATION_PLUGIN}

30
root-common/usr/share/container-scripts/mysql/cnf/40-paas.cnf
View file

@ -1,30 +0,0 @@
[mysqld]
#
# Settings configured by the user
#
# Sets how the table names are stored and compared. Default: 0
lower_case_table_names = ${MYSQL_LOWER_CASE_TABLE_NAMES}
# Sets whether queries should be logged
general_log = ${MYSQL_LOG_QUERIES_ENABLED}
general_log_file = ${MYSQL_DATADIR}/mysql-query.log
# The maximum permitted number of simultaneous client connections. Default: 151
max_connections = ${MYSQL_MAX_CONNECTIONS}
# The minimum/maximum lengths of the word to be included in a FULLTEXT index. Default: 4/20
ft_min_word_len = ${MYSQL_FT_MIN_WORD_LEN}
ft_max_word_len = ${MYSQL_FT_MAX_WORD_LEN}
# In case the native AIO is broken. Default: 1
# See http://help.directadmin.com/item.php?id=529
innodb_use_native_aio = ${MYSQL_AIO}
[myisamchk]
# The minimum/maximum lengths of the word to be included in a FULLTEXT index. Default: 4/20
#
# To ensure that myisamchk and the server use the same values for full-text
# parameters, we placed them in both sections.
ft_min_word_len = ${MYSQL_FT_MIN_WORD_LEN}
ft_max_word_len = ${MYSQL_FT_MAX_WORD_LEN}

27
root-common/usr/share/container-scripts/mysql/cnf/50-my-tuning.cnf
View file

@ -1,27 +0,0 @@
[mysqld]
key_buffer_size = ${MYSQL_KEY_BUFFER_SIZE}
max_allowed_packet = ${MYSQL_MAX_ALLOWED_PACKET}
table_open_cache = ${MYSQL_TABLE_OPEN_CACHE}
sort_buffer_size = ${MYSQL_SORT_BUFFER_SIZE}
read_buffer_size = ${MYSQL_READ_BUFFER_SIZE}
read_rnd_buffer_size = 256K
net_buffer_length = 2K
thread_stack = 256K
myisam_sort_buffer_size = 2M
# It is recommended that innodb_buffer_pool_size is configured to 50 to 75 percent of system memory.
innodb_buffer_pool_size = ${MYSQL_INNODB_BUFFER_POOL_SIZE}
# Set .._log_file_size to 25 % of buffer pool size
innodb_log_file_size = ${MYSQL_INNODB_LOG_FILE_SIZE}
innodb_log_buffer_size = ${MYSQL_INNODB_LOG_BUFFER_SIZE}
[mysqldump]
quick
max_allowed_packet = 16M
[mysql]
no-auto-rehash
[myisamchk]
key_buffer_size = 8M
sort_buffer_size = 8M

318
root-common/usr/share/container-scripts/mysql/common.sh
View file

@ -1,318 +0,0 @@
#!/bin/bash
source ${CONTAINER_SCRIPTS_PATH}/helpers.sh
# Data directory where MySQL database files live. The data subdirectory is here
# because .bashrc and my.cnf both live in /var/lib/mysql/ and we don't want a
# volume to override it.
export MYSQL_DATADIR=/var/lib/mysql/data
# Unix local domain socket to connect to MySQL server
export MYSQL_LOCAL_SOCKET=/tmp/mysql.sock
# Configuration settings.
export MYSQL_DEFAULTS_FILE=${MYSQL_DEFAULTS_FILE:-/etc/my.cnf}
function export_setting_variables() {
export MYSQL_BINLOG_FORMAT=${MYSQL_BINLOG_FORMAT:-STATEMENT}
export MYSQL_LOWER_CASE_TABLE_NAMES=${MYSQL_LOWER_CASE_TABLE_NAMES:-0}
export MYSQL_LOG_QUERIES_ENABLED=${MYSQL_LOG_QUERIES_ENABLED:-0}
export MYSQL_MAX_CONNECTIONS=${MYSQL_MAX_CONNECTIONS:-151}
export MYSQL_FT_MIN_WORD_LEN=${MYSQL_FT_MIN_WORD_LEN:-4}
export MYSQL_FT_MAX_WORD_LEN=${MYSQL_FT_MAX_WORD_LEN:-20}
export MYSQL_AIO=${MYSQL_AIO:-1}
export MYSQL_MAX_ALLOWED_PACKET=${MYSQL_MAX_ALLOWED_PACKET:-200M}
export MYSQL_TABLE_OPEN_CACHE=${MYSQL_TABLE_OPEN_CACHE:-400}
export MYSQL_SORT_BUFFER_SIZE=${MYSQL_SORT_BUFFER_SIZE:-256K}
# Export memory limit variables and calculate limits
local export_vars=$(cgroup-limits) && export $export_vars || exit 1
if [ -n "${NO_MEMORY_LIMIT:-}" -o -z "${MEMORY_LIMIT_IN_BYTES:-}" ]; then
export MYSQL_KEY_BUFFER_SIZE=${MYSQL_KEY_BUFFER_SIZE:-32M}
export MYSQL_READ_BUFFER_SIZE=${MYSQL_READ_BUFFER_SIZE:-8M}
export MYSQL_INNODB_BUFFER_POOL_SIZE=${MYSQL_INNODB_BUFFER_POOL_SIZE:-32M}
export MYSQL_INNODB_LOG_FILE_SIZE=${MYSQL_INNODB_LOG_FILE_SIZE:-8M}
export MYSQL_INNODB_LOG_BUFFER_SIZE=${MYSQL_INNODB_LOG_BUFFER_SIZE:-8M}
else
export MYSQL_KEY_BUFFER_SIZE=${MYSQL_KEY_BUFFER_SIZE:-$((MEMORY_LIMIT_IN_BYTES/1024/1024/10))M}
export MYSQL_READ_BUFFER_SIZE=${MYSQL_READ_BUFFER_SIZE:-$((MEMORY_LIMIT_IN_BYTES/1024/1024/20))M}
export MYSQL_INNODB_BUFFER_POOL_SIZE=${MYSQL_INNODB_BUFFER_POOL_SIZE:-$((MEMORY_LIMIT_IN_BYTES/1024/1024/2))M}
# We are multiplying by 15 first and dividing by 100 later so we get as much
# precision as possible with whole numbers. Result is 15% of memory.
export MYSQL_INNODB_LOG_FILE_SIZE=${MYSQL_INNODB_LOG_FILE_SIZE:-$((MEMORY_LIMIT_IN_BYTES*15/1024/1024/100))M}
export MYSQL_INNODB_LOG_BUFFER_SIZE=${MYSQL_INNODB_LOG_BUFFER_SIZE:-$((MEMORY_LIMIT_IN_BYTES*15/1024/1024/100))M}
fi
export MYSQL_DATADIR_ACTION=${MYSQL_DATADIR_ACTION:-upgrade-warn}
export MYSQL_DEFAULT_AUTHENTICATION_PLUGIN=${MYSQL_DEFAULT_AUTHENTICATION_PLUGIN:-caching_sha2_password}
}
# this stores whether the database was initialized from empty datadir
export MYSQL_DATADIR_FIRST_INIT=false
# Be paranoid and stricter than we should be.
# https://dev.mysql.com/doc/refman/en/identifiers.html
mysql_identifier_regex='^[a-zA-Z0-9_]+$'
mysql_password_regex='^[a-zA-Z0-9_~!@#$%^&*()-=<>,.?;:|]+$'
# Variables that are used to connect to local mysql during initialization
mysql_flags="-u root --socket=$MYSQL_LOCAL_SOCKET"
admin_flags="--defaults-file=$MYSQL_DEFAULTS_FILE $mysql_flags"
# Make sure env variables don't propagate to mysqld process.
function unset_env_vars() {
log_info 'Cleaning up environment variables MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE and MYSQL_ROOT_PASSWORD ...'
unset MYSQL_USER MYSQL_PASSWORD MYSQL_DATABASE MYSQL_ROOT_PASSWORD
}
# Poll until MySQL responds to our ping.
function wait_for_mysql() {
pid=$1 ; shift
while true; do
if [ -d "/proc/$pid" ]; then
mysqladmin $admin_flags ping &>/dev/null && log_info "MySQL started successfully" && return 0
else
return 1
fi
log_info "Waiting for MySQL to start ..."
sleep 1
done
}
function wait_for_mysql_shutdown() {
while pgrep -f "${MYSQL_PREFIX}/libexec/mysqld" >/dev/null; do
log_info "Waiting for MySQL to shutdown ..."
sleep 1
done
}
# Start local MySQL server with a defaults file
function start_local_mysql() {
log_info 'Starting MySQL server with disabled networking ...'
${MYSQL_PREFIX}/libexec/mysqld \
--defaults-file=$MYSQL_DEFAULTS_FILE \
--skip-networking --socket=$MYSQL_LOCAL_SOCKET "$@" &
mysql_pid=$!
wait_for_mysql $mysql_pid
}
# Shutdown mysql flushing privileges
function shutdown_local_mysql() {
log_info 'Shutting down MySQL ...'
mysqladmin $admin_flags flush-privileges shutdown
wait_for_mysql_shutdown
}
# Initialize the MySQL database (create user accounts and the initial database)
function initialize_database() {
log_info 'Initializing database ...'
if [ "`version2number $MYSQL_VERSION`" -lt '800' ] ; then
log_initialization ${MYSQL_PREFIX}/libexec/mysqld --initialize --datadir=$MYSQL_DATADIR --ignore-db-dir=lost+found
else
log_initialization ${MYSQL_PREFIX}/libexec/mysqld --initialize --datadir=$MYSQL_DATADIR
fi
# The '--initialize' option sets an auto generated root password.
mysql_flags="$mysql_flags -p${AUTOGENERATED_ROOT_PASSWORD}"
admin_flags="--defaults-file=$MYSQL_DEFAULTS_FILE $mysql_flags"
start_local_mysql "$@"
# The first valid connection after running 'mysql --initialize' must use
# the --connect-expired-password option and set a new root password.
mysql_flags="$mysql_flags --connect-expired-password"
admin_flags="--defaults-file=$MYSQL_DEFAULTS_FILE $mysql_flags"
# As we have a temporary auto generated root password, the first thing to do is to
# change it. We try first to set it to an empty password, but if this is not allowed
# (due to validate_plugin, for example), we then set it to MYSQL_ROOT_PASSWORD.
if [ -v MYSQL_ROOT_PASSWORD ]; then
log_info "Setting password for MySQL root user ..."
set +e
mysql $mysql_flags -e "ALTER USER 'root'@'localhost' IDENTIFIED BY '';"
RETCODE=$?
set -e
if [ $RETCODE -eq 0 ]; then
mysql_flags="-u root --socket=$MYSQL_LOCAL_SOCKET"
else
mysql $mysql_flags -e "ALTER USER 'root'@'localhost' IDENTIFIED BY '${MYSQL_ROOT_PASSWORD}';"
mysql_flags="-u root --socket=$MYSQL_LOCAL_SOCKET -p${MYSQL_ROOT_PASSWORD}"
fi
mysql $mysql_flags <<EOSQL
CREATE USER IF NOT EXISTS 'root'@'%' IDENTIFIED BY '${MYSQL_ROOT_PASSWORD}';
GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' WITH GRANT OPTION;
EOSQL
else
mysql $mysql_flags -e "ALTER USER 'root'@'localhost' IDENTIFIED BY ''";
mysql_flags="-u root --socket=$MYSQL_LOCAL_SOCKET"
fi
admin_flags="--defaults-file=$MYSQL_DEFAULTS_FILE $mysql_flags"
# Running mysql_upgrade creates the mysql_upgrade_info file in the data dir,
# which is necessary to detect which version of the mysqld daemon created the data.
# Checking empty file should not take longer than a second and one extra check should not harm.
mysql_upgrade ${admin_flags}
if [ -v MYSQL_RUNNING_AS_SLAVE ]; then
log_info 'Initialization finished'
return 0
fi
# Do not care what option is compulsory here, just create what is specified
if [ -v MYSQL_USER ]; then
log_info "Creating user specified by MYSQL_USER (${MYSQL_USER}) ..."
mysql $mysql_flags <<EOSQL
CREATE USER '${MYSQL_USER}'@'%' IDENTIFIED BY '${MYSQL_PASSWORD}';
EOSQL
fi
if [ -v MYSQL_DATABASE ]; then
log_info "Creating database ${MYSQL_DATABASE} ..."
mysqladmin $admin_flags create "${MYSQL_DATABASE}"
if [ -v MYSQL_USER ]; then
log_info "Granting privileges to user ${MYSQL_USER} for ${MYSQL_DATABASE} ..."
mysql $mysql_flags <<EOSQL
GRANT ALL ON \`${MYSQL_DATABASE}\`.* TO '${MYSQL_USER}'@'%' ;
FLUSH PRIVILEGES ;
EOSQL
fi
fi
log_info 'Initialization finished'
# remember that the database was just initialized, it may be needed on other places
export MYSQL_DATADIR_FIRST_INIT=true
}
# The 'server_id' number for slave needs to be within 1-4294967295 range.
# This function will take the 'hostname' if the container, hash it and turn it
# into the number.
# See: https://dev.mysql.com/doc/refman/en/replication-options.html#option_mysqld_server-id
function server_id() {
checksum=$(sha256sum <<< $(hostname -I))
checksum=${checksum:0:14}
echo -n $((0x${checksum}%4294967295))
}
function wait_for_mysql_master() {
while true; do
log_info "Waiting for MySQL master (${MYSQL_MASTER_SERVICE_NAME}) to accept connections ..."
mysqladmin --host=${MYSQL_MASTER_SERVICE_NAME} --user="${MYSQL_MASTER_USER}" \
--password="${MYSQL_MASTER_PASSWORD}" ping &>/dev/null && log_info "MySQL master is ready" && return 0
sleep 1
done
}
# get_matched_files finds file for image extending
function get_matched_files() {
local custom_dir default_dir
custom_dir="$1"
default_dir="$2"
files_matched="$3"
find "$default_dir" -maxdepth 1 -type f -name "$files_matched" -printf "%f\n"
[ -d "$custom_dir" ] && find "$custom_dir" -maxdepth 1 -type f -name "$files_matched" -printf "%f\n"
}
# process_extending_files process extending files in $1 and $2 directories
# - source all *.sh files
# (if there are files with same name source only file from $1)
function process_extending_files() {
local custom_dir default_dir
custom_dir=$1
default_dir=$2
while read filename ; do
echo "=> sourcing $filename ..."
# Custom file is prefered
if [ -f $custom_dir/$filename ]; then
source $custom_dir/$filename
else
source $default_dir/$filename
fi
done <<<"$(get_matched_files "$custom_dir" "$default_dir" '*.sh' | sort -u)"
}
# process extending config files in $1 and $2 directories
# - expand variables in *.cnf and copy the files into /etc/my.cnf.d directory
# (if there are files with same name source only file from $1)
function process_extending_config_files() {
local custom_dir default_dir
custom_dir=$1
default_dir=$2
while read filename ; do
echo "=> sourcing $filename ..."
# Custom file is prefered
if [ -f $custom_dir/$filename ]; then
envsubst < $custom_dir/$filename > /etc/my.cnf.d/$filename
else
envsubst < $default_dir/$filename > /etc/my.cnf.d/$filename
fi
done <<<"$(get_matched_files "$custom_dir" "$default_dir" '*.cnf' | sort -u)"
}
# Converts string version to the integer format (5.5.33 is converted to 505,
# 10.1.23-MariaDB is converted into 1001, etc.
function version2number() {
local version_major=$(echo "$1" | grep -o -e '^[0-9]*\.[0-9]*')
printf %d%02d ${version_major%%.*} ${version_major##*.}
}
# Converts the version in format of an integer into major.minor
function number2version() {
local numver=${1}
echo $((numver / 100)).$((numver % 100))
}
# Prints version of the mysqld that is currently available (string)
function mysqld_version() {
${MYSQL_PREFIX}/libexec/mysqld -V | awk '{print $3}'
}
# Returns version from the daemon in integer format
function mysqld_compat_version() {
version2number $(mysqld_version)
}
# Returns version from the datadir in the integer format
function get_datadir_version() {
local datadir="$1"
local upgrade_info_file=$(get_mysql_upgrade_info_file "$datadir")
[ -r "$upgrade_info_file" ] || return
local version_text=$(cat "$upgrade_info_file" | head -n 1)
version2number "${version_text}"
}
# Returns name of the file in the datadir that holds version information about the data
function get_mysql_upgrade_info_file() {
local datadir="$1"
echo "$datadir/mysql_upgrade_info"
}
# Writes version string of the daemon into mysql_upgrade_info file
# (should be only used when the file is missing and only during limited time;
# once most deployments include this version file, we should leave it on
# scripts to generate the file right after initialization or when upgrading)
function write_mysql_upgrade_info_file() {
local datadir="$1"
local version=$(mysqld_version)
local upgrade_info_file=$(get_mysql_upgrade_info_file "$datadir")
if [ -f "$datadir/mysql_upgrade_info" ] ; then
echo "File ${upgrade_info_file} exists, nothing is done."
else
log_info "Storing version '${version}' information into the data dir '${upgrade_info_file}'"
echo "${version}" > "${upgrade_info_file}"
mysqld_version >"$datadir/mysql_upgrade_info"
fi
}
# Checks if mysql server is allowing connection for 'root'@'localhost' without password
function is_allowing_connection_with_empty_password() {
set +e
mysql -u root --socket=$MYSQL_LOCAL_SOCKET -e "DO 0;" # NO-OP command, just to test the connection
RETCODE=$?
set -e
return $RETCODE
}

36
root-common/usr/share/container-scripts/mysql/helpers.sh
View file

@ -1,36 +0,0 @@
function log_info {
echo "---> `date +%T` $@"
}
function log_warn {
echo "---> `date +%T` Warning: $@"
}
function log_and_run {
log_info "Running $@"
"$@"
}
function log_initialization {
log_info "Running $@"
AUTOGENERATED_ROOT_PASSWORD="$("$@" 2>&1 | grep "temporary password" | awk '{print $NF}')"
}
function log_volume_info {
CONTAINER_DEBUG=${CONTAINER_DEBUG:-}
if [[ "${CONTAINER_DEBUG,,}" != "true" ]]; then
return
fi
log_info "Volume info for $@:"
set +e
log_and_run mount
while [ $# -gt 0 ]; do
log_and_run ls -alZ $1
shift
done
set -e
if [[ -v DEBUG_IGNORE_SCRIPT_FAILURES ]]; then
set +e
fi
}

113
root-common/usr/share/container-scripts/mysql/init/40-datadir-action.sh
View file

@ -1,113 +0,0 @@
upstream_upgrade_info() {
echo -n "For upstream documentation about upgrading, see: "
case ${MYSQL_VERSION} in
10.0) echo "https://mariadb.com/kb/en/library/upgrading-from-mariadb-55-to-mariadb-100/" ;;
10.1) echo "https://mariadb.com/kb/en/library/upgrading-from-mariadb-100-to-mariadb-101/" ;;
10.2) echo "https://mariadb.com/kb/en/library/upgrading-from-mariadb-101-to-mariadb-102/" ;;
5.6) echo "https://dev.mysql.com/doc/refman/5.6/en/upgrading-from-previous-series.html" ;;
5.7) echo "https://dev.mysql.com/doc/refman/5.7/en/upgrading-from-previous-series.html" ;;
8.0) echo "https://dev.mysql.com/doc/refman/8.0/en/upgrading-from-previous-series.html" ;;
*) echo "Non expected version '${MYSQL_VERSION}'" ; return 1 ;;
esac
}
check_datadir_version() {
local datadir="$1"
local datadir_version=$(get_datadir_version "$datadir")
local mysqld_version=$(mysqld_compat_version)
local datadir_version_dot=$(number2version "${datadir_version}")
local mysqld_version_dot=$(number2version "${mysqld_version}")
for datadir_action in ${MYSQL_DATADIR_ACTION//,/ } ; do
log_info "Running datadir action: ${datadir_action}"
case ${datadir_action} in
upgrade-auto|upgrade-warn)
if [ -z "${datadir_version}" ] || [ "${datadir_version}" -eq 0 ] ; then
# Writing the info file, since historically it was not written
log_warn "Version of the data could not be determined."\
"It is because the file mysql_upgrade_info is missing in the data directory, which"\
"is most probably because it was not created when initialization of data directory."\
"In order to allow seamless updates to the next higher version in the future,"\
"the file mysql_upgrade_info will be created."\
"If the data directory was created with a different version than ${mysqld_version_dot},"\
"it is required to run this container with the MYSQL_DATADIR_ACTION environment variable"\
"set to 'force', or run 'mysql_upgrade' utility manually; the mysql_upgrade tool"\
"checks the tables and creates such a file as well. $(upstream_upgrade_info)"
write_mysql_upgrade_info_file "${MYSQL_DATADIR}"
continue
# This is currently a dead-code, but should be enabled after the mysql_upgrade_info
# file gets to the deployments (after few months most of the deployments should already have the file)
log_warn "Version of the data could not be determined."\
"Running such a container is risky."\
"The current daemon version is ${mysqld_version_dot}."\
"If you are not sure whether the data directory is compatible with the current"\
"version ${mysqld_version_dot}, restore the data from a back-up."\
"If restoring from a back-up is not possible, create a file 'mysql_upgrade_info'"\
"that includes version information (${mysqld_version_dot} in this case) in the root"\
"of the data directory."\
"In order to create the 'mysql_upgrade_info' file, either run this container with"\
"the MYSQL_DATADIR_ACTION environment variable set to 'force', or run 'mysql_upgrade' utility"\
"manually; the mysql_upgrade tool checks the tables and creates such a file as well."\
"That will enable correct upgrade check in the future. $(upstream_upgrade_info)"
fi
if [ "${datadir_version}" -eq "${mysqld_version}" ] ; then
log_info "MySQL server version check passed, both server and data directory"\
"are version ${mysqld_version_dot}."
continue
fi
if [ $(( ${datadir_version} + 1 )) -eq "${mysqld_version}" -o "${datadir_version}" -eq 505 -a "${mysqld_version}" -eq 1000 \
-o "${datadir_version}" -eq 507 -a "${mysqld_version}" -eq 800 ]; then
log_warn "MySQL server is version ${mysqld_version_dot} and datadir is version"\
"${datadir_version_dot}, which is a compatible combination."
if [ "${MYSQL_DATADIR_ACTION}" == 'upgrade-auto' ] ; then
log_info "The data directory will be upgraded automatically from ${datadir_version_dot}"\
"to version ${mysqld_version_dot}. $(upstream_upgrade_info)"
log_and_run mysql_upgrade ${mysql_flags}
else
log_warn "Automatic upgrade is not turned on, proceed with the upgrade."\
"In order to upgrade the data directory, run this container with the MYSQL_DATADIR_ACTION"\
"environment variable set to 'upgrade-auto' or run mysql_upgrade manually. $(upstream_upgrade_info)"
fi
else
log_warn "MySQL server is version ${mysqld_version_dot} and datadir is version"\
"${datadir_version_dot}, which are incompatible. Remember, that upgrade is only supported"\
"by upstream from previous version and it is not allowed to skip versions. $(upstream_upgrade_info)"
if [ "${datadir_version}" -gt "${mysqld_version}" ] ; then
log_warn "Downgrading to the lower version is not supported. Consider"\
"dumping data and load them again into a fresh instance. $(upstream_upgrade_info)"
fi
log_warn "Consider restoring the database from a back-up. To ignore this"\
"warning, set 'MYSQL_DATADIR_ACTION' variable to 'upgrade-force', but this may result in data corruption. $(upstream_upgrade_info)"
return 1
fi
;;
upgrade-force)
log_and_run mysql_upgrade ${mysql_flags} --force
;;
optimize)
log_and_run mysqlcheck ${mysql_flags} --optimize --all-databases --force
;;
analyze)
log_and_run mysqlcheck ${mysql_flags} --analyze --all-databases --force
;;
disable)
log_info "Nothing is done about the data directory."
;;
*)
log_warn "Unknown value of MYSQL_DATADIR_ACTION variable: '${MYSQL_DATADIR_ACTION}', ignoring."
;;
esac
done
}
check_datadir_version "${MYSQL_DATADIR}"
unset -f check_datadir_version upstream_upgrade_info

37
root-common/usr/share/container-scripts/mysql/init/50-passwd-change.sh
View file

@ -1,37 +0,0 @@
password_change() {
log_info 'Setting passwords ...'
# Set the password for MySQL user and root everytime this container is started.
# This allows to change the password by editing the deployment configuration.
if [[ -v MYSQL_USER && -v MYSQL_PASSWORD ]]; then
local user_maches=$(echo "SELECT COUNT(*) AS found FROM mysql.user WHERE user='${MYSQL_USER}' AND Host='%' \G" | mysql $mysql_flags)
if ! echo "${user_maches}" | grep -q 'found: 1' ; then
log_info "WARNING: User ${MYSQL_USER} does not exist in database. Password not changed."
else
mysql $mysql_flags <<EOSQL
ALTER USER '${MYSQL_USER}'@'%' IDENTIFIED BY '${MYSQL_PASSWORD}';
EOSQL
fi
fi
# The MYSQL_ROOT_PASSWORD is optional, therefore we need to either enable remote
# access with a password if the variable is set or disable remote access otherwise.
if [ -v MYSQL_ROOT_PASSWORD ]; then
mysql $mysql_flags <<EOSQL
CREATE USER IF NOT EXISTS 'root'@'%';
ALTER USER 'root'@'%' IDENTIFIED BY '${MYSQL_ROOT_PASSWORD}';
GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' WITH GRANT OPTION;
EOSQL
else
mysql $mysql_flags <<EOSQL
DROP USER IF EXISTS 'root'@'%';
FLUSH PRIVILEGES;
EOSQL
fi
}
if ! [ -v MYSQL_RUNNING_AS_SLAVE ] ; then
password_change
fi
unset -f password_change

0
root-common/usr/share/container-scripts/mysql/post-init.sh
View file

81
root-common/usr/share/container-scripts/mysql/pre-init/20-validate-variables.sh
View file

@ -1,81 +0,0 @@
function usage() {
[ $# == 1 ] && echo "error: $1"
echo "You must either specify the following environment variables:"
echo " MYSQL_USER (regex: '$mysql_identifier_regex')"
echo " MYSQL_PASSWORD (regex: '$mysql_password_regex')"
echo " MYSQL_DATABASE (regex: '$mysql_identifier_regex')"
echo "Or the following environment variable:"
echo " MYSQL_ROOT_PASSWORD (regex: '$mysql_password_regex')"
echo "Or both."
echo "Optional Settings:"
echo " MYSQL_LOWER_CASE_TABLE_NAMES (default: 0)"
echo " MYSQL_LOG_QUERIES_ENABLED (default: 0)"
echo " MYSQL_MAX_CONNECTIONS (default: 151)"
echo " MYSQL_FT_MIN_WORD_LEN (default: 4)"
echo " MYSQL_FT_MAX_WORD_LEN (default: 20)"
echo " MYSQL_AIO (default: 1)"
echo " MYSQL_KEY_BUFFER_SIZE (default: 32M or 10% of available memory)"
echo " MYSQL_MAX_ALLOWED_PACKET (default: 200M)"
echo " MYSQL_TABLE_OPEN_CACHE (default: 400)"
echo " MYSQL_SORT_BUFFER_SIZE (default: 256K)"
echo " MYSQL_READ_BUFFER_SIZE (default: 8M or 5% of available memory)"
echo " MYSQL_INNODB_BUFFER_POOL_SIZE (default: 32M or 50% of available memory)"
echo " MYSQL_INNODB_LOG_FILE_SIZE (default: 8M or 15% of available memory)"
echo " MYSQL_INNODB_LOG_BUFFER_SIZE (default: 8M or 15% of available memory)"
echo
echo "For more information, see https://github.com/sclorg/mysql-container"
exit 1
}
function validate_variables() {
# Check basic sanity of specified variables
if [[ -v MYSQL_USER && -v MYSQL_PASSWORD ]]; then
[[ "$MYSQL_USER" =~ $mysql_identifier_regex ]] || usage "Invalid MySQL username"
[ ${#MYSQL_USER} -le 32 ] || usage "MySQL username too long (maximum 32 characters)"
[[ "$MYSQL_PASSWORD" =~ $mysql_password_regex ]] || usage "Invalid password"
user_specified=1
fi
if [ -v MYSQL_ROOT_PASSWORD ]; then
[[ "$MYSQL_ROOT_PASSWORD" =~ $mysql_password_regex ]] || usage "Invalid root password"
root_specified=1
fi
# If MYSQL_USER == "root", we have a special case
if [[ "${user_specified:-0}" == "1" && "$MYSQL_USER" == "root" ]]; then
if [[ "${root_specified:-0}" == "1" ]]; then
usage "When setting MYSQL_USER to 'root' you can only set either MYSQL_PASSWORD or MYSQL_ROOT_PASSWORD"
fi
# We will now behave as if MYSQL_USER was not specified
export MYSQL_ROOT_PASSWORD="$MYSQL_PASSWORD"
export -n MYSQL_USER
export -n MYSQL_PASSWORD
user_specified=0
root_specified=1
fi
# Either combination of user/pass/db or root password is ok
if [[ "${user_specified:-0}" == "0" && "${root_specified:-0}" == "0" ]]; then
usage
fi
# If the root user is not specified, database name is required
if [[ "${root_specified:-0}" == "0" ]]; then
[ -v MYSQL_DATABASE ] || usage "You need to specify database name or root password"
fi
if [ -v MYSQL_DATABASE ]; then
[[ "$MYSQL_DATABASE" =~ $mysql_identifier_regex ]] || usage "Invalid database name"
[ ${#MYSQL_DATABASE} -le 64 ] || usage "Database name too long (maximum 64 characters)"
fi
# Specifically check of incomplete specification
if [[ -v MYSQL_USER || -v MYSQL_PASSWORD || -v MYSQL_DATABASE ]] && \
[[ "${user_specified:-0}" == "0" ]]; then
usage
fi
}
if ! [ -v MYSQL_RUNNING_AS_SLAVE ] ; then
validate_variables
fi

21
root-common/usr/share/container-scripts/mysql/pre-init/25-validate-replication-variables.sh
View file

@ -1,21 +0,0 @@
function validate_replication_variables() {
if ! [[ -v MYSQL_DATABASE && -v MYSQL_MASTER_USER && -v MYSQL_MASTER_PASSWORD && \
( "${MYSQL_RUNNING_AS_SLAVE:-0}" != "1" || -v MYSQL_MASTER_SERVICE_NAME ) ]]; then
echo
echo "For master/slave replication, you have to specify following environment variables:"
echo " MYSQL_MASTER_SERVICE_NAME (slave only)"
echo " MYSQL_DATABASE"
echo " MYSQL_MASTER_USER"
echo " MYSQL_MASTER_PASSWORD"
echo
return 1
fi
[[ "$MYSQL_DATABASE" =~ $mysql_identifier_regex ]] || usage "Invalid database name"
[[ "$MYSQL_MASTER_USER" =~ $mysql_identifier_regex ]] || usage "Invalid MySQL master username"
[ ${#MYSQL_MASTER_USER} -le 16 ] || usage "MySQL master username too long (maximum 16 characters)"
[[ "$MYSQL_MASTER_PASSWORD" =~ $mysql_password_regex ]] || usage "Invalid MySQL master password"
}
if [ -v MYSQL_RUNNING_AS_MASTER ] || [ -v MYSQL_RUNNING_AS_SLAVE ] ; then
validate_replication_variables
fi

3
root-common/usr/share/container-scripts/mysql/pre-init/30-base-config.sh
View file

@ -1,3 +0,0 @@
log_info 'Processing basic MySQL configuration files ...'
envsubst < ${CONTAINER_SCRIPTS_PATH}/pre-init/my-base.cnf.template > /etc/my.cnf.d/base.cnf

17
root-common/usr/share/container-scripts/mysql/pre-init/60-replication-config.sh
View file

@ -1,17 +0,0 @@
# mysqld configuration for replication scenarios
if [ -v MYSQL_RUNNING_AS_MASTER ] || [ -v MYSQL_RUNNING_AS_SLAVE ] ; then
log_info 'Processing basic MySQL configuration for replication (master and slave) files ...'
envsubst < ${CONTAINER_SCRIPTS_PATH}/pre-init/my-repl-gtid.cnf.template > /etc/my.cnf.d/repl-gtid.cnf
fi
if [ -v MYSQL_RUNNING_AS_MASTER ] ; then
log_info 'Processing basic MySQL configuration for replication (master only) files ...'
envsubst < ${CONTAINER_SCRIPTS_PATH}/pre-init/my-master.cnf.template > /etc/my.cnf.d/master.cnf
fi
if [ -v MYSQL_RUNNING_AS_SLAVE ] ; then
log_info 'Processing basic MySQL configuration for replication (slave only) files ...'
envsubst < ${CONTAINER_SCRIPTS_PATH}/pre-init/my-slave.cnf.template > /etc/my.cnf.d/slave.cnf
fi

6
root-common/usr/share/container-scripts/mysql/pre-init/70-s2i-config.sh
View file

@ -1,6 +0,0 @@
# additional arbitrary mysqld configuration provided by user using s2i
log_info 'Processing additional arbitrary MySQL configuration provided by s2i ...'
process_extending_config_files ${APP_DATA}/mysql-cfg/ ${CONTAINER_SCRIPTS_PATH}/cnf/

5
root-common/usr/share/container-scripts/mysql/pre-init/my-base.cnf.template
View file

@ -1,5 +0,0 @@
[mysqld]
datadir = ${MYSQL_DATADIR}
basedir = ${MYSQL_PREFIX}
plugin-dir = ${MYSQL_PREFIX}/lib64/mysql/plugin

7
root-common/usr/share/container-scripts/mysql/pre-init/my-master.cnf.template
View file

@ -1,7 +0,0 @@
[mysqld]
server-id = ${MYSQL_SERVER_ID}
log_bin = ${MYSQL_DATADIR}/mysql-bin.log
binlog_do_db = mysql
binlog_do_db = ${MYSQL_DATABASE}
binlog_format = ${MYSQL_BINLOG_FORMAT}

6
root-common/usr/share/container-scripts/mysql/pre-init/my-repl-gtid.cnf.template
View file

@ -1,6 +0,0 @@
[mysqld]
gtid_mode = ON
log-slave-updates = ON
enforce-gtid-consistency = ON

7
root-common/usr/share/container-scripts/mysql/pre-init/my-slave.cnf.template
View file

@ -1,7 +0,0 @@
[mysqld]
server-id = ${MYSQL_SERVER_ID}
log_bin = ${MYSQL_DATADIR}/mysql-bin.log
relay-log = ${MYSQL_DATADIR}/mysql-relay-bin.log
binlog_do_db = mysql
binlog_do_db = ${MYSQL_DATABASE}

3
root-common/usr/share/container-scripts/mysql/scl_enable
View file

@ -1,3 +0,0 @@
# This will make scl collection binaries work out of box.
unset BASH_ENV PROMPT_COMMAND ENV
source scl_source enable ${ENABLED_COLLECTIONS}

374
root/usr/share/container-scripts/mysql/README.md
View file

@ -1,374 +0,0 @@
MySQL 8.0 SQL Database Server container image
==========================================
This container image includes MySQL 8.0 SQL database server for OpenShift and general usage.
Users can choose between RHEL, CentOS and Fedora based 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
-----------
This container image provides a containerized packaging of the MySQL mysqld daemon
and client application. The mysqld server daemon accepts connections from clients
and provides access to content from MySQL databases on behalf of the clients.
You can find more information on the MySQL project from the project Web site
(https://www.mysql.com/).
Usage
-----
For this, we will assume that you are using the MySQL 8.0 container image from the
Red Hat Container Catalog called `rhscl/mysql-80-rhel7`.
If you want to set only the mandatory environment variables and not store
the database in a host directory, execute the following command:
```
$ podman run -d --name mysql_database -e MYSQL_USER=user -e MYSQL_PASSWORD=pass -e MYSQL_DATABASE=db -p 3306:3306 rhscl/mysql-80-rhel7
```
This will create a container named `mysql_database` running MySQL with database
`db` and user with credentials `user:pass`. Port 3306 will be exposed and mapped
to the host. If you want your database to be persistent across container executions,
also add a `-v /host/db/path:/var/lib/mysql/data` argument. This will be the MySQL
data directory.
If the database directory is not initialized, the entrypoint script will first
run [`mysql_install_db`](https://dev.mysql.com/doc/refman/en/mysql-install-db.html)
and setup necessary database users and passwords. After the database is initialized,
or if it was already present, `mysqld` is executed and will run as PID 1. You can
stop the detached container by running `podman stop mysql_database`.
Environment variables and volumes
---------------------------------
The image recognizes the following environment variables that you can set during
initialization by passing `-e VAR=VALUE` to the Docker run command.
**`MYSQL_USER`**
User name for MySQL account to be created
**`MYSQL_PASSWORD`**
Password for the user account
**`MYSQL_DATABASE`**
Database name
**`MYSQL_ROOT_PASSWORD`**
Password for the root user (optional)
The following environment variables influence the MySQL configuration file. They are all optional.
**`MYSQL_LOWER_CASE_TABLE_NAMES (default: 0)`**
Sets how the table names are stored and compared
**`MYSQL_MAX_CONNECTIONS (default: 151)`**
The maximum permitted number of simultaneous client connections
**`MYSQL_MAX_ALLOWED_PACKET (default: 200M)`**
The maximum size of one packet or any generated/intermediate string
**`MYSQL_FT_MIN_WORD_LEN (default: 4)`**
The minimum length of the word to be included in a FULLTEXT index
**`MYSQL_FT_MAX_WORD_LEN (default: 20)`**
The maximum length of the word to be included in a FULLTEXT index
**`MYSQL_AIO (default: 1)`**
Controls the `innodb_use_native_aio` setting value in case the native AIO is broken. See http://help.directadmin.com/item.php?id=529
**`MYSQL_TABLE_OPEN_CACHE (default: 400)`**
The number of open tables for all threads
**`MYSQL_KEY_BUFFER_SIZE (default: 32M or 10% of available memory)`**
The size of the buffer used for index blocks
**`MYSQL_SORT_BUFFER_SIZE (default: 256K)`**
The size of the buffer used for sorting
**`MYSQL_READ_BUFFER_SIZE (default: 8M or 5% of available memory)`**
The size of the buffer used for a sequential scan
**`MYSQL_INNODB_BUFFER_POOL_SIZE (default: 32M or 50% of available memory)`**
The size of the buffer pool where InnoDB caches table and index data
**`MYSQL_INNODB_LOG_FILE_SIZE (default: 8M or 15% of available memory)`**
The size of each log file in a log group
**`MYSQL_INNODB_LOG_BUFFER_SIZE (default: 8M or 15% of available memory)`**
The size of the buffer that InnoDB uses to write to the log files on disk
**`MYSQL_DEFAULTS_FILE (default: /etc/my.cnf)`**
Point to an alternative configuration file
**`MYSQL_BINLOG_FORMAT (default: statement)`**
Set sets the binlog format, supported values are `row` and `statement`
**`MYSQL_LOG_QUERIES_ENABLED (default: 0)`**
To enable query logging set this to `1`
**`MYSQL_DEFAULT_AUTHENTICATION_PLUGIN (default: caching_sha2_password)`**
Set default authentication plugin. Accepts values `mysql_native_password` or `caching_sha2_password`.
You can also set the following mount points by passing the `-v /host:/container` flag to Docker.
**`/var/lib/mysql/data`**
MySQL data directory
**Notice: When mouting a directory from the host into the container, ensure that the mounted
directory has the appropriate permissions and that the owner and group of the directory
matches the user UID or name which is running inside the container.**
MySQL auto-tuning
-----------------
When the MySQL image is run with the `--memory` parameter set and you didn't
specify value for some parameters, their values will be automatically
calculated based on the available memory.
**`MYSQL_KEY_BUFFER_SIZE (default: 10%)`**
`key_buffer_size`
**`MYSQL_READ_BUFFER_SIZE (default: 5%)`**
`read_buffer_size`
**`MYSQL_INNODB_BUFFER_POOL_SIZE (default: 50%)`**
`innodb_buffer_pool_size`
**`MYSQL_INNODB_LOG_FILE_SIZE (default: 15%)`**
`innodb_log_file_size`
**`MYSQL_INNODB_LOG_BUFFER_SIZE (default: 15%)`**
`innodb_log_buffer_size`
MySQL root user
---------------------------------
The root user has no password set by default, only allowing local connections.
You can set it by setting the `MYSQL_ROOT_PASSWORD` environment variable. This
will allow you to login to the root account remotely. Local connections will
still not require a password.
To disable remote root access, simply unset `MYSQL_ROOT_PASSWORD` and restart
the container.
Changing passwords
------------------
Since passwords are part of the image configuration, the only supported method
to change passwords for the database user (`MYSQL_USER`) and root user is by
changing the environment variables `MYSQL_PASSWORD` and `MYSQL_ROOT_PASSWORD`,
respectively.
Changing database passwords through SQL statements or any way other than through
the environment variables aforementioned will cause a mismatch between the
values stored in the variables and the actual passwords. Whenever a database
container starts it will reset the passwords to the values stored in the
environment variables.
Default my.cnf file
-------------------
With environment variables we are able to customize a lot of different parameters
or configurations for the mysql bootstrap configurations. If you'd prefer to use
your own configuration file, you can override the `MYSQL_DEFAULTS_FILE` env
variable with the full path of the file you wish to use. For example, the default
location is `/etc/my.cnf` but you can change it to `/etc/mysql/my.cnf` by setting
`MYSQL_DEFAULTS_FILE=/etc/mysql/my.cnf`
Extending image
---------------
This image can be extended in Openshift using the `Source` build strategy or via the standalone
[source-to-image](https://github.com/openshift/source-to-image) application (where available).
For this, we will assume that you are using the `rhscl/mysql-80-rhel7` image,
available via `mysql:8.0` imagestream tag in Openshift.
For example, to build a customized MySQL database image `my-mysql-rhel7`
with a configuration from `https://github.com/sclorg/mysql-container/tree/master/examples/extend-image` run:
```
$ oc new-app mysql:8.0~https://github.com/sclorg/mysql-container.git \
--name my-mysql-rhel7 \
--context-dir=examples/extend-image \
--env MYSQL_OPERATIONS_USER=opuser \
--env MYSQL_OPERATIONS_PASSWORD=oppass \
--env MYSQL_DATABASE=opdb \
--env MYSQL_USER=user \
--env MYSQL_PASSWORD=pass
```
or via s2i:
```
$ s2i build --context-dir=examples/extend-image https://github.com/sclorg/mysql-container.git rhscl/mysql-80-rhel7 my-mysql-rhel7
```
The directory passed to Openshift can contain these directories:
`mysql-cfg/`
When starting the container, files from this directory will be used as
a configuration for the `mysqld` daemon.
`envsubst` command is run on this file to still allow customization of
the image using environmental variables
`mysql-pre-init/`
Shell scripts (`*.sh`) available in this directory are sourced before
`mysqld` daemon is started.
`mysql-init/`
Shell scripts (`*.sh`) available in this directory are sourced when
`mysqld` daemon is started locally. In this phase, use `${mysql_flags}`
to connect to the locally running daemon, for example `mysql $mysql_flags < dump.sql`
Variables that can be used in the scripts provided to s2i:
`$mysql_flags`
arguments for the `mysql` tool that will connect to the locally running `mysqld` during initialization
`$MYSQL_RUNNING_AS_MASTER`
variable defined when the container is run with `run-mysqld-master` command
`$MYSQL_RUNNING_AS_SLAVE`
variable defined when the container is run with `run-mysqld-slave` command
`$MYSQL_DATADIR_FIRST_INIT`
variable defined when the container was initialized from the empty data dir
During the s2i build all provided files are copied into `/opt/app-root/src`
directory into the resulting image. If some configuration files are present
in the destination directory, files with the same name are overwritten.
Also only one file with the same name can be used for customization and user
provided files are preferred over default files in
`/usr/share/container-scripts/mysql/`- so it is possible to overwrite them.
Same configuration directory structure can be used to customize the image
every time the image is started using `podman run`. The directory has to be
mounted into `/opt/app-root/src/` in the image
(`-v ./image-configuration/:/opt/app-root/src/`).
This overwrites customization built into the image.
Securing the connection with SSL
--------------------------------
In order to secure the connection with SSL, use the extending feature described
above. In particular, put the SSL certificates into a separate directory:
sslapp/mysql-certs/server-cert-selfsigned.pem
sslapp/mysql-certs/server-key.pem
And then put a separate configuration file into mysql-cfg:
$> cat sslapp/mysql-cfg/ssl.cnf
[mysqld]
ssl-key=${APP_DATA}/mysql-certs/server-key.pem
ssl-cert=${APP_DATA}/mysql-certs/server-cert-selfsigned.pem
Such a directory `sslapp` can then be mounted into the container with -v,
or a new container image can be built using s2i.
Upgrading and data directory version checking
---------------------------------------------
MySQL and MariaDB use versions that consist of three numbers X.Y.Z (e.g. 5.6.23).
For version changes in Z part, the server's binary data format stays compatible and thus no
special upgrade procedure is needed. For upgrades from X.Y to X.Y+1, consider doing manual
steps as described at
https://dev.mysql.com/doc/refman/8.0/en/upgrading-from-previous-series.html.
Skipping versions like from X.Y to X.Y+2 or downgrading to lower version is not supported;
the only exception is ugrading from MariaDB 5.5 to MariaDB 10.0.
**Important**: Upgrading to a new version is always risky and users are expected to make a full
back-up of all data before.
A safer solution to upgrade is to dump all data using `mysqldump` or `mysqldbexport` and then
load the data using `mysql` or `mysqldbimport` into an empty (freshly initialized) database.
Another way of proceeding with the upgrade is starting the new version of the `mysqld` daemon
and run `mysql_upgrade` right after the start. This so called in-place upgrade is generally
faster for large data directory, but only possible if upgrading from the very previous version,
so skipping versions is not supported.
This container detects whether the data needs to be upgraded using `mysql_upgrade` and
we can control it by setting `MYSQL_DATADIR_ACTION` variable, which can have one or more of the following values:
* `upgrade-warn` -- If the data version can be determined and the data come from a different version
of the daemon, a warning is printed but the container starts. This is the default value.
Since historically the version file `mysql_upgrade_info` was not created, when using this option,
the version file is created if not exist, but no `mysql_upgrade` will be called.
However, this automatic creation will be removed after few months, since the version should be
created on most deployments at that point.
* `upgrade-auto` -- `mysql_upgrade` is run at the beginning of the container start, when the local
daemon is running, but only if the data version can be determined and the data come
with the very previous version. A warning is printed if the data come from even older
or newer version. This value effectively enables automatic upgrades,
but it is always risky and users should still back-up all the data before starting the newer container.
Set this option only if you have very good back-ups at any moment and you are fine to fail-over
from the back-up.
* `upgrade-force` -- `mysql_upgrade --force` is run at the beginning of the container start, when the local
daemon is running, no matter what version of the daemon the data come from.
This is also the way to create the missing version file `mysql_upgrade_info` if not present
in the root of the data directory; this file holds information about the version of the data.
There are also some other actions that you may want to run at the beginning of the container start,
when the local daemon is running, no matter what version of the data is detected:
* `optimize` -- runs `mysqlcheck --optimize`. It optimizes all the tables.
* `analyze` -- runs `mysqlcheck --analyze`. It analyzes all the tables.
* `disable` -- nothing is done regarding data directory version.
Multiple values are separated by comma and run in-order, e.g. `MYSQL_DATADIR_ACTION="optimize,analyze"`.
Changing the replication binlog_format
--------------------------------------
Some applications may wish to use `row` binlog_formats (for example, those built
with change-data-capture in mind). The default replication/binlog format is
`statement` but to change it you can set the `MYSQL_BINLOG_FORMAT` environment
variable. For example `MYSQL_BINLOG_FORMAT=row`. Now when you run the database
with `master` replication turned on (ie, set the Docker/container `cmd` to be
`run-mysqld-master`) the binlog will emit the actual data for the rows that change
as opposed to the statements (ie, DML like insert...) that caused the change.
Changing the authentication plugin
----------------------------------
MySQL 8.0 introduced 'caching_sha2_password' as its default authentication plugin.
It is faster and provides better security then the previous default authentication plugin.
However, not all software implements this algorithm, and client applications might report
issue like "The server requested authentication method".
The plugin can be changed by setting `MYSQL_DEFAULT_AUTHENTICATION_PLUGIN` environment variable,
which accepts values `caching_sha2_password` (the default one) or `mysql_native_password`.
To change the behaviour back to the same behavior as MySQL 5.7 (for client applications that do not
support `caching_sha2_password`), set the `MYSQL_DEFAULT_AUTHENTICATION_PLUGIN=mysql_native_password`.
Troubleshooting
---------------
The mysqld deamon in the container logs to the standard output, so the log is available in the container log. The log can be examined by running:
podman logs <container>
See also
--------
Dockerfile and other sources for this container image are available on
https://github.com/sclorg/mysql-container.
In that repository, the Dockerfile for CentOS is called Dockerfile, the Dockerfile
for RHEL7 is called Dockerfile.rhel7, the Dockerfile for RHEL8 is called Dockerfile.rhel8,
and the Dockerfile for Fedora is called Dockerfile.fedora.

13
s2i-common/bin/assemble
View file

@ -1,13 +0,0 @@
#!/bin/bash
set -o errexit
set -o nounset
set -o pipefail
shopt -s dotglob
echo "---> Installing application source ..."
mv /tmp/src/* ./ 2>/dev/null || true
# Fix source directory permissions
/usr/libexec/fix-permissions ./

1
s2i-common/bin/run
View file

@ -1 +0,0 @@
/bin/run-mysqld

8
s2i-common/bin/usage
View file

@ -1,8 +0,0 @@
#!/bin/sh
set -o errexit
set -o nounset
set -o pipefail
groff -t -man -ETascii /help.1

273
test/mysql-ephemeral-template.json
View file

@ -1,273 +0,0 @@
{
"kind": "Template",
"apiVersion": "v1",
"metadata": {
"name": "mysql-ephemeral",
"annotations": {
"openshift.io/display-name": "MySQL (Ephemeral)",
"description": "MySQL database service, without persistent storage. For more information about using this template, including OpenShift considerations, see https://github.com/sclorg/mysql-container/blob/master/8.0/root/usr/share/container-scripts/mysql/README.md.\n\nWARNING: Any data stored will be lost upon pod destruction. Only use this template for testing",
"iconClass": "icon-mysql-database",
"tags": "database,mysql",
"openshift.io/long-description": "This template provides a standalone MySQL server with a database created. The database is not stored on persistent storage, so any restart of the service will result in all data being lost. The database name, username, and password are chosen via parameters when provisioning this service.",
"openshift.io/provider-display-name": "Red Hat, Inc.",
"openshift.io/documentation-url": "https://docs.okd.io/latest/using_images/db_images/mysql.html",
"openshift.io/support-url": "https://access.redhat.com"
}
},
"message": "The following service(s) have been created in your project: ${DATABASE_SERVICE_NAME}.\n\n Username: ${MYSQL_USER}\n Password: ${MYSQL_PASSWORD}\n Database Name: ${MYSQL_DATABASE}\n Connection URL: mysql://${DATABASE_SERVICE_NAME}:3306/\n\nFor more information about using this template, including OpenShift considerations, see https://github.com/sclorg/mysql-container/blob/master/8.0/root/usr/share/container-scripts/mysql/README.md.",
"labels": {
"template": "mysql-ephemeral-template"
},
"objects": [
{
"kind": "Secret",
"apiVersion": "v1",
"metadata": {
"name": "${DATABASE_SERVICE_NAME}",
"annotations": {
"template.openshift.io/expose-username": "{.data['database-user']}",
"template.openshift.io/expose-password": "{.data['database-password']}",
"template.openshift.io/expose-root_password": "{.data['database-root-password']}",
"template.openshift.io/expose-database_name": "{.data['database-name']}"
}
},
"stringData" : {
"database-user" : "${MYSQL_USER}",
"database-password" : "${MYSQL_PASSWORD}",
"database-root-password" : "${MYSQL_ROOT_PASSWORD}",
"database-name" : "${MYSQL_DATABASE}"
}
},
{
"kind": "Service",
"apiVersion": "v1",
"metadata": {
"name": "${DATABASE_SERVICE_NAME}",
"annotations": {
"template.openshift.io/expose-uri": "mysql://{.spec.clusterIP}:{.spec.ports[?(.name==\"mysql\")].port}"
}
},
"spec": {
"ports": [
{
"name": "mysql",
"protocol": "TCP",
"port": 3306,
"targetPort": 3306,
"nodePort": 0
}
],
"selector": {
"name": "${DATABASE_SERVICE_NAME}"
},
"type": "ClusterIP",
"sessionAffinity": "None"
},
"status": {
"loadBalancer": {}
}
},
{
"kind": "DeploymentConfig",
"apiVersion": "v1",
"metadata": {
"name": "${DATABASE_SERVICE_NAME}",
"annotations": {
"template.alpha.openshift.io/wait-for-ready": "true"
}
},
"spec": {
"strategy": {
"type": "Recreate"
},
"triggers": [
{
"type": "ImageChange",
"imageChangeParams": {
"automatic": true,
"containerNames": [
"mysql"
],
"from": {
"kind": "ImageStreamTag",
"name": "mysql:${MYSQL_VERSION}",
"namespace": "${NAMESPACE}"
},
"lastTriggeredImage": ""
}
},
{
"type": "ConfigChange"
}
],
"replicas": 1,
"selector": {
"name": "${DATABASE_SERVICE_NAME}"
},
"template": {
"metadata": {
"labels": {
"name": "${DATABASE_SERVICE_NAME}"
}
},
"spec": {
"containers": [
{
"name": "mysql",
"image": " ",
"ports": [
{
"containerPort": 3306,
"protocol": "TCP"
}
],
"readinessProbe": {
"timeoutSeconds": 1,
"initialDelaySeconds": 5,
"exec": {
"command": [ "/bin/sh", "-i", "-c",
"MYSQL_PWD=\"$MYSQL_PASSWORD\" mysql -h 127.0.0.1 -u $MYSQL_USER -D $MYSQL_DATABASE -e 'SELECT 1'"]
}
},
"livenessProbe": {
"timeoutSeconds": 1,
"initialDelaySeconds": 30,
"tcpSocket": {
"port": 3306
}
},
"env": [
{
"name": "MYSQL_USER",
"valueFrom": {
"secretKeyRef" : {
"name" : "${DATABASE_SERVICE_NAME}",
"key" : "database-user"
}
}
},
{
"name": "MYSQL_PASSWORD",
"valueFrom": {
"secretKeyRef" : {
"name" : "${DATABASE_SERVICE_NAME}",
"key" : "database-password"
}
}
},
{
"name": "MYSQL_ROOT_PASSWORD",
"valueFrom": {
"secretKeyRef" : {
"name" : "${DATABASE_SERVICE_NAME}",
"key" : "database-root-password"
}
}
},
{
"name": "MYSQL_DATABASE",
"valueFrom": {
"secretKeyRef" : {
"name" : "${DATABASE_SERVICE_NAME}",
"key" : "database-name"
}
}
}
],
"resources": {
"limits": {
"memory": "${MEMORY_LIMIT}"
}
},
"volumeMounts": [
{
"name": "${DATABASE_SERVICE_NAME}-data",
"mountPath": "/var/lib/mysql/data"
}
],
"terminationMessagePath": "/dev/termination-log",
"imagePullPolicy": "IfNotPresent",
"capabilities": {},
"securityContext": {
"capabilities": {},
"privileged": false
}
}
],
"volumes": [
{
"name": "${DATABASE_SERVICE_NAME}-data",
"emptyDir": {
"medium": ""
}
}
],
"restartPolicy": "Always",
"dnsPolicy": "ClusterFirst"
}
}
},
"status": {}
}
],
"parameters": [
{
"name": "MEMORY_LIMIT",
"displayName": "Memory Limit",
"description": "Maximum amount of memory the container can use.",
"value": "512Mi",
"required": true
},
{
"name": "NAMESPACE",
"displayName": "Namespace",
"description": "The OpenShift Namespace where the ImageStream resides.",
"value": "openshift"
},
{
"name": "DATABASE_SERVICE_NAME",
"displayName": "Database Service Name",
"description": "The name of the OpenShift Service exposed for the database.",
"value": "mysql",
"required": true
},
{
"name": "MYSQL_USER",
"displayName": "MySQL Connection Username",
"description": "Username for MySQL user that will be used for accessing the database.",
"generate": "expression",
"from": "user[A-Z0-9]{3}",
"required": true
},
{
"name": "MYSQL_PASSWORD",
"displayName": "MySQL Connection Password",
"description": "Password for the MySQL connection user.",
"generate": "expression",
"from": "[a-zA-Z0-9]{16}",
"required": true
},
{
"name": "MYSQL_ROOT_PASSWORD",
"displayName": "MySQL root user Password",
"description": "Password for the MySQL root user.",
"generate": "expression",
"from": "[a-zA-Z0-9]{16}",
"required": true
},
{
"name": "MYSQL_DATABASE",
"displayName": "MySQL Database Name",
"description": "Name of the MySQL database accessed.",
"value": "sampledb",
"required": true
},
{
"name": "MYSQL_VERSION",
"displayName": "Version of MySQL Image",
"description": "Version of MySQL image to be used (8.0, or latest).",
"value": "8.0",
"required": true
}
]
}

665
test/run
View file

@ -1,665 +0,0 @@
#!/bin/bash
#
# Test the MySQL image.
#
# IMAGE_NAME specifies the name of the candidate image used for testing.
# The image has to be available before this script is executed.
#
set -o errexit
set -o nounset
shopt -s nullglob
THISDIR=$(dirname ${BASH_SOURCE[0]})
source ${THISDIR}/test-lib.sh
TEST_LIST="\
run_container_creation_tests
run_configuration_tests
run_general_tests
run_change_password_test
run_change_password_new_user_test
run_replication_test
run_doc_test
run_s2i_test
run_ssl_test
run_upgrade_test
"
if [ -e "${IMAGE_NAME:-}" ] ; then
echo "Error: IMAGE_NAME must be specified"
exit 1
fi
CID_FILE_DIR=$(mktemp --suffix=mysql_test_cidfiles -d)
TESTSUITE_RESULT=1
test_dir="$(readlink -f $(dirname "${BASH_SOURCE[0]}"))"
s2i_args="--pull-policy=never "
function cleanup() {
ct_cleanup
if [ $TESTSUITE_RESULT -eq 0 ] ; then
echo "Tests for ${IMAGE_NAME} succeeded."
else
echo "Tests for ${IMAGE_NAME} failed."
fi
}
trap cleanup EXIT SIGINT
function mysql_cmd() {
local container_ip="$1"; shift
local login="$1"; shift
local password="$1"; shift
docker run --rm ${CONTAINER_EXTRA_ARGS:-} "$IMAGE_NAME" mysql --host "$container_ip" -u"$login" -p"$password" "$@" db
}
function test_connection() {
local name=$1 ; shift
local login=$1 ; shift
local password=$1 ; shift
local ip
ip=$(ct_get_cip $name)
echo " Testing MySQL connection to $ip..."
local max_attempts=60
local sleep_time=3
local i
local status=''
echo -n " Trying to connect..."
for i in $(seq $max_attempts); do
local status=$(docker inspect -f '{{.State.Status}}' $(ct_get_cid "${name}"))
if [ "${status}" != 'running' ] ; then
break;
fi
echo -n "."
if mysql_cmd "$ip" "$login" "$password" &>/dev/null <<< 'SELECT 1;'; then
echo " OK"
echo " Success!"
return 0
fi
sleep $sleep_time
done
echo " FAIL"
echo " Giving up: Failed to connect."
if [ "${status}" == 'running' ] ; then
echo " Container is still running."
else
local exit_status=$(docker inspect -f '{{.State.ExitCode}}' ${name})
echo " Container finised with exit code ${exit_status}."
fi
echo "Logs:"
docker logs $(ct_get_cid $name)
return 1
}
function test_mysql() {
local container_ip="$1"
local login="$2"
local password="$3"
echo " Testing MySQL"
mysql_cmd "$container_ip" "$login" "$password" <<< 'CREATE TABLE tbl (col1 VARCHAR(20), col2 VARCHAR(20));'
mysql_cmd "$container_ip" "$login" "$password" <<< 'INSERT INTO tbl VALUES ("foo1", "bar1");'
mysql_cmd "$container_ip" "$login" "$password" <<< 'INSERT INTO tbl VALUES ("foo2", "bar2");'
mysql_cmd "$container_ip" "$login" "$password" <<< 'INSERT INTO tbl VALUES ("foo3", "bar3");'
mysql_cmd "$container_ip" "$login" "$password" <<< 'SELECT * FROM tbl;'
mysql_cmd "$container_ip" "$login" "$password" <<< 'DROP TABLE tbl;'
echo " Success!"
}
function create_container() {
local name=$1 ; shift
cidfile="$CID_FILE_DIR/$name"
# create container with a cidfile in a directory for cleanup
local container_id
container_id="$(docker run ${DOCKER_ARGS:-} --cidfile $cidfile -d "$@" $IMAGE_NAME ${CONTAINER_ARGS:-})"
echo " Created container $container_id"
}
function run_change_password_test() {
local tmpdir=$(mktemp -d)
chmod -R a+rwx "${tmpdir}"
# Create MySQL container with persistent volume and set the initial password
create_container "testpass1" -e MYSQL_USER=user -e MYSQL_PASSWORD=foo \
-e MYSQL_DATABASE=db -v ${tmpdir}:/var/lib/mysql/data:Z
test_connection testpass1 user foo
docker stop $(ct_get_cid testpass1) >/dev/null
# Create second container with changed password
create_container "testpass2" -e MYSQL_USER=user -e MYSQL_PASSWORD=bar \
-e MYSQL_DATABASE=db -v ${tmpdir}:/var/lib/mysql/data:Z
test_connection testpass2 user bar
# The old password should not work anymore
if mysql_cmd "$(ct_get_cip testpass2)" user foo -e 'SELECT 1;'; then
return 1
fi
}
function run_change_password_new_user_test() {
local tmpdir=$(mktemp -d)
chmod -R a+rwx "${tmpdir}"
# Create MySQL container with persistent volume and set the initial password
create_container "testpassnewuser1" -e MYSQL_USER=user -e MYSQL_PASSWORD=foo \
-e MYSQL_DATABASE=db -v ${tmpdir}:/var/lib/mysql/data:Z
test_connection testpassnewuser1 user foo
docker stop $(ct_get_cid testpassnewuser1) >/dev/null
# Create second container with changed password
create_container "testpassnewuser2" -e MYSQL_USER=user2 -e MYSQL_PASSWORD=bar \
-e MYSQL_DATABASE=db -v ${tmpdir}:/var/lib/mysql/data:Z
test_connection testpassnewuser2 user foo
# See whether there is an error message in the log
if ! docker logs $(ct_get_cid testpassnewuser2) | grep 'User user2 does not exist in database' ; then
echo "ERROR: Container did not end with expected error message: 'User user2 does not exist in database'."
return 1
fi
# The new password should not work
if mysql_cmd "$(ct_get_cip testpassnewuser2)" user bar -e 'SELECT 1;'; then
echo "ERROR: The new password should not work, but it does."
return 1
fi
}
function run_replication_test() {
local cluster_args="-e MYSQL_MASTER_USER=master -e MYSQL_MASTER_PASSWORD=master -e MYSQL_DATABASE=db"
local max_attempts=120
# Run the MySQL master
docker run $cluster_args -e MYSQL_USER=user -e MYSQL_PASSWORD=foo \
-e MYSQL_ROOT_PASSWORD=root \
-e MYSQL_INNODB_BUFFER_POOL_SIZE=5M \
-d --cidfile ${CID_FILE_DIR}/master.cid $IMAGE_NAME mysqld-master >/dev/null
local master_ip
master_ip=$(ct_get_cip master.cid)
# Run the MySQL slave
docker run $cluster_args -e MYSQL_MASTER_SERVICE_NAME=${master_ip} \
-e MYSQL_INNODB_BUFFER_POOL_SIZE=5M \
-d --cidfile ${CID_FILE_DIR}/slave.cid $IMAGE_NAME mysqld-slave >/dev/null
local slave_ip
slave_ip=$(ct_get_cip slave.cid)
# Now wait till the MASTER will see the SLAVE
local i
for i in $(seq $max_attempts); do
result="$(mysql_cmd "$master_ip" root root -e 'SHOW SLAVE HOSTS;' | grep "$slave_ip" || true)"
if [[ -n "${result}" ]]; then
echo "${slave_ip} successfully registered as SLAVE for ${master_ip}"
break
fi
if [[ "${i}" == "${max_attempts}" ]]; then
echo "The ${slave_ip} failed to register in MASTER"
echo "Dumping logs for $(ct_get_cid slave.cid)"
docker logs $(ct_get_cid slave.cid)
return 1
fi
sleep 3
done
# do some real work to test replication in practice
mysql_cmd "$master_ip" root root -e "CREATE TABLE t1 (a INT); INSERT INTO t1 VALUES (24);"
# read value from slave and check whether it is expectd
for i in $(seq $max_attempts); do
set +e
result="$(mysql_cmd "${slave_ip}" root root -e "select * from t1 \G" | grep -e ^a | grep 24)"
set -e
if [[ ! -z "${result}" ]]; then
echo "${slave_ip} successfully got value from MASTER ${master_ip}"
break
fi
if [[ "${i}" == "${max_attempts}" ]]; then
echo "The ${slave_ip} failed to see value added on MASTER"
echo "Dumping logs for $(ct_get_cid slave.cid)"
docker logs $(ct_get_cid slave.cid)
return 1
fi
sleep 3
done
}
function assert_login_access() {
local container_ip=$1; shift
local USER=$1 ; shift
local PASS=$1 ; shift
local success=$1 ; shift
if mysql_cmd "$container_ip" "$USER" "$PASS" <<< 'SELECT 1;' ; then
if $success ; then
echo " $USER($PASS) access granted as expected"
return
fi
else
if ! $success ; then
echo " $USER($PASS) access denied as expected"
return
fi
fi
echo " $USER($PASS) login assertion failed"
exit 1
}
function assert_local_access() {
local id="$1" ; shift
if docker exec $(ct_get_cid "$id") bash -c 'mysql -uroot <<< "SELECT 1;"' ; then
echo " local access granted as expected"
return
fi
echo " local access assertion failed"
return 1
}
# Make sure the invocation of docker run fails.
function assert_container_creation_fails() {
# Time the docker run command. It should fail. If it doesn't fail,
# mysqld will keep running so we kill it with SIGKILL to make sure
# timeout returns a non-zero value.
local ret=0
timeout -s 9 --preserve-status 60s docker run --rm "$@" $IMAGE_NAME >/dev/null || ret=$?
# Timeout will exit with a high number.
if [ $ret -gt 30 ]; then
return 1
fi
echo " Success!"
}
function try_image_invalid_combinations() {
assert_container_creation_fails -e MYSQL_USER=user -e MYSQL_DATABASE=db "$@"
assert_container_creation_fails -e MYSQL_PASSWORD=pass -e MYSQL_DATABASE=db "$@"
}
function run_container_creation_tests() {
echo " Testing image entrypoint usage"
assert_container_creation_fails
try_image_invalid_combinations
try_image_invalid_combinations -e MYSQL_ROOT_PASSWORD=root_pass
local VERY_LONG_DB_NAME="very_long_database_name_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
local VERY_LONG_USER_NAME="very_long_user_name_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
assert_container_creation_fails -e MYSQL_USER=user -e MYSQL_PASSWORD=pass
assert_container_creation_fails -e MYSQL_USER=\$invalid -e MYSQL_PASSWORD=pass -e MYSQL_DATABASE=db -e MYSQL_ROOT_PASSWORD=root_pass
assert_container_creation_fails -e MYSQL_USER=$VERY_LONG_USER_NAME -e MYSQL_PASSWORD=pass -e MYSQL_DATABASE=db -e MYSQL_ROOT_PASSWORD=root_pass
assert_container_creation_fails -e MYSQL_USER=user -e MYSQL_PASSWORD="\"" -e MYSQL_DATABASE=db -e MYSQL_ROOT_PASSWORD=root_pass
assert_container_creation_fails -e MYSQL_USER=user -e MYSQL_PASSWORD=pass -e MYSQL_DATABASE=\$invalid -e MYSQL_ROOT_PASSWORD=root_pass
assert_container_creation_fails -e MYSQL_USER=user -e MYSQL_PASSWORD=pass -e MYSQL_DATABASE=$VERY_LONG_DB_NAME -e MYSQL_ROOT_PASSWORD=root_pass
assert_container_creation_fails -e MYSQL_USER=user -e MYSQL_PASSWORD=pass -e MYSQL_DATABASE=db -e MYSQL_ROOT_PASSWORD="\""
assert_container_creation_fails -e MYSQL_USER=root -e MYSQL_PASSWORD=pass -e MYSQL_DATABASE=db -e MYSQL_ROOT_PASSWORD=pass
echo " Success!"
}
function test_config_option() {
local container_name="$1"
local configuration="$2"
local option_name="$3"
local option_value="$4"
if ! echo "$configuration" | grep -qx "$option_name[[:space:]]*=[[:space:]]*$option_value"; then
local configs="$(docker exec "$(ct_get_cid $container_name)" bash -c 'set +f; shopt -s nullglob; echo /etc/my.cnf /etc/my.cnf.d/* /opt/rh/mysql*/root/etc/my.cnf /opt/rh/mysql*/root/etc/my.cnf.d/* | paste -s')"
echo >&2 "FAIL: option '$option_name' should have value '$option_value', but it wasn't found in any of the configuration files ($configs):"
echo >&2
echo >&2 "$configuration"
echo >&2
return 1
fi
return 0
}
function run_configuration_tests() {
echo " Testing image configuration settings"
local container_name=config_test
create_container \
"$container_name" \
--env MYSQL_USER=config_test_user \
--env MYSQL_PASSWORD=config_test \
--env MYSQL_DATABASE=db \
--env MYSQL_LOWER_CASE_TABLE_NAMES=1 \
--env MYSQL_LOG_QUERIES_ENABLED=1 \
--env MYSQL_MAX_CONNECTIONS=1337 \
--env MYSQL_FT_MIN_WORD_LEN=8 \
--env MYSQL_FT_MAX_WORD_LEN=15 \
--env MYSQL_MAX_ALLOWED_PACKET=10M \
--env MYSQL_TABLE_OPEN_CACHE=100 \
--env MYSQL_SORT_BUFFER_SIZE=256K \
--env MYSQL_KEY_BUFFER_SIZE=16M \
--env MYSQL_READ_BUFFER_SIZE=16M \
--env MYSQL_INNODB_BUFFER_POOL_SIZE=16M \
--env MYSQL_INNODB_LOG_FILE_SIZE=4M \
--env MYSQL_INNODB_LOG_BUFFER_SIZE=4M \
--env MYSQL_DEFAULT_AUTHENTICATION_PLUGIN=mysql_native_password \
--env WORKAROUND_DOCKER_BUG_14203=
#
test_connection "$container_name" config_test_user config_test
# TODO: this check is far from perfect and could be improved:
# - we should look for an option in the desired config, not in all of them
# - we should respect section of the config (now we have duplicated options from a different sections)
local configuration
configuration="$(docker exec "$(ct_get_cid $container_name)" bash -c 'set +f; shopt -s nullglob; egrep -hv "^(#|\!|\[|$)" /etc/my.cnf /etc/my.cnf.d/* /opt/rh/mysql*/root/etc/my.cnf /opt/rh/mysql*/root/etc/my.cnf.d/*' | sed 's,\(^[[:space:]]\+\|[[:space:]]\+$\),,' | sort -u)"
test_config_option "$container_name" "$configuration" lower_case_table_names 1
test_config_option "$container_name" "$configuration" general_log 1
test_config_option "$container_name" "$configuration" max_connections 1337
test_config_option "$container_name" "$configuration" ft_min_word_len 8
test_config_option "$container_name" "$configuration" ft_max_word_len 15
test_config_option "$container_name" "$configuration" max_allowed_packet 10M
test_config_option "$container_name" "$configuration" table_open_cache 100
test_config_option "$container_name" "$configuration" sort_buffer_size 256K
test_config_option "$container_name" "$configuration" key_buffer_size 16M
test_config_option "$container_name" "$configuration" read_buffer_size 16M
test_config_option "$container_name" "$configuration" innodb_buffer_pool_size 16M
test_config_option "$container_name" "$configuration" innodb_log_file_size 4M
test_config_option "$container_name" "$configuration" innodb_log_buffer_size 4M
test_config_option "$container_name" "$configuration" default_authentication_plugin mysql_native_password
docker stop "$(ct_get_cid $container_name)" >/dev/null
echo " Success!"
echo " Testing image auto-calculated configuration settings"
container_name=dynamic_config_test
DOCKER_ARGS='--memory=512m' create_container \
"$container_name" \
--env MYSQL_USER=config_test_user \
--env MYSQL_PASSWORD=config_test \
--env MYSQL_DATABASE=db
test_connection "$container_name" config_test_user config_test
configuration="$(docker exec "$(ct_get_cid $container_name)" bash -c 'set +f; shopt -s nullglob; egrep -hv "^(#|\!|\[|$)" /etc/my.cnf /etc/my.cnf.d/* /opt/rh/mysql*/root/etc/my.cnf /opt/rh/mysql*/root/etc/my.cnf.d/*' | sed 's,\(^[[:space:]]\+\|[[:space:]]\+$\),,' | sort -u)"
test_config_option "$container_name" "$configuration" key_buffer_size 51M
test_config_option "$container_name" "$configuration" read_buffer_size 25M
test_config_option "$container_name" "$configuration" innodb_buffer_pool_size 256M
test_config_option "$container_name" "$configuration" innodb_log_file_size 76M
test_config_option "$container_name" "$configuration" innodb_log_buffer_size 76M
# here we test the default value for default_authentication_plugin
test_config_option "$container_name" "$configuration" default_authentication_plugin caching_sha2_password
docker stop "$(ct_get_cid $container_name)" >/dev/null
echo " Success!"
}
function run_tests() {
local name=$1 ; shift
envs="-e MYSQL_USER=$USER -e MYSQL_PASSWORD=$PASS -e MYSQL_DATABASE=db"
if [ -v ROOT_PASS ]; then
envs="$envs -e MYSQL_ROOT_PASSWORD=$ROOT_PASS"
fi
create_container $name $envs
test_connection "$name" "$USER" "$PASS"
echo " Testing scl usage"
ct_scl_usage_old $name 'mysql --version' "$VERSION"
echo " Testing login accesses"
local container_ip
container_ip=$(ct_get_cip $name)
assert_login_access "$container_ip" "$USER" "$PASS" true
assert_login_access "$container_ip" "$USER" "${PASS}_foo" false
if [ -v ROOT_PASS ]; then
assert_login_access "$container_ip" root "$ROOT_PASS" true
assert_login_access "$container_ip" root "${ROOT_PASS}_foo" false
else
assert_login_access "$container_ip" root 'foo' false
assert_login_access "$container_ip" root '' false
fi
assert_local_access "$name"
echo " Success!"
test_mysql "$container_ip" "$USER" "$PASS"
}
run_doc_test() {
echo " Testing documentation in the container image"
ct_doc_content_old "MYSQL\_ROOT\_PASSWORD" volume 3306
echo " Success!"
echo
}
_s2i_test_image() {
local container_name="$1"
local mount_opts="$2"
echo " Testing s2i app image with invalid configuration"
assert_container_creation_fails -e MYSQL_USER=root -e MYSQL_PASSWORD=pass -e MYSQL_DATABASE=db -e MYSQL_ROOT_PASSWORD=pass
echo " Testing s2i app image with correct configuration"
create_container \
"$container_name" \
--env MYSQL_USER=config_test_user \
--env MYSQL_PASSWORD=config_test \
--env MYSQL_DATABASE=db \
--env MYSQL_OPERATIONS_USER=operations_user \
--env MYSQL_OPERATIONS_PASSWORD=operations_pass \
${mount_opts}
test_connection "$container_name" operations_user operations_pass
configuration="$(docker exec "$(ct_get_cid $container_name)" bash -c 'set +f; shopt -s nullglob; egrep -hv "^(#|\!|\[|$)" /etc/my.cnf /etc/my.cnf.d/* /opt/rh/mysql*/root/etc/my.cnf /opt/rh/mysql*/root/etc/my.cnf.d/*' | sed 's,\(^[[:space:]]\+\|[[:space:]]\+$\),,' | sort -u)"
docker stop "$(ct_get_cid $container_name)" >/dev/null
}
run_s2i_test() {
echo " Testing s2i usage"
ct_s2i_usage ${IMAGE_NAME} ${s2i_args} &>/dev/null
echo " Testing s2i build"
ct_s2i_build_as_df file://${test_dir}/test-app ${IMAGE_NAME} ${IMAGE_NAME}-testapp
local image_name_backup=${IMAGE_NAME}
export IMAGE_NAME=${IMAGE_NAME}-testapp
local container_name=s2i_config_build
_s2i_test_image "s2i_config_build" ""
# return back original value for IMAGE_NAME
export IMAGE_NAME=${image_name_backup}
echo " Testing s2i mount"
test_app_dir=$(mktemp -d)
cp -Lr ${test_dir}/test-app ${test_app_dir}/
chown -R 27:27 ${test_app_dir}
_s2i_test_image "_s2i_test_mount" "-v ${test_app_dir}/test-app:/opt/app-root/src/:z"
rm -rf ${test_app_dir}
echo " Success!"
}
gen_self_signed_cert() {
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' > ${output_dir}/${base_name}-req.pem
openssl req -new -x509 -nodes -key ${output_dir}/${base_name}-key.pem -batch > ${output_dir}/${base_name}-cert-selfsigned.pem
}
run_ssl_test() {
echo " Testing ssl usage"
test_app_dir=$(mktemp -d)
mkdir -p ${test_app_dir}/{mysql-certs,mysql-cfg}
gen_self_signed_cert ${test_app_dir}/mysql-certs server
echo "[mysqld]
ssl-key=\${APP_DATA}/mysql-certs/server-key.pem
ssl-cert=\${APP_DATA}/mysql-certs/server-cert-selfsigned.pem
" >${test_app_dir}/mysql-cfg/ssl.cnf
chown -R 27:27 ${test_app_dir}
local ca_cert_path="/opt/app-root/src/mysql-certs/server-cert-selfsigned.pem"
create_container \
"_s2i_test_ssl" \
--env MYSQL_USER=ssl_test_user \
--env MYSQL_PASSWORD=ssl_test \
--env MYSQL_DATABASE=db \
-v ${test_app_dir}:/opt/app-root/src/:z
test_connection "_s2i_test_ssl" ssl_test_user ssl_test
ip=$(ct_get_cip _s2i_test_ssl)
# At least MySQL 5.6 requires ssl-ca option on client side, otherwise the ssl is not used
CONTAINER_EXTRA_ARGS="-v ${test_app_dir}:/opt/app-root/src/:z"
# MySQL requires --ssl-mode to be set in order to require SSL
case ${VERSION} in
5*) ssl_mode_opt='--ssl-mode=REQUIRED'
esac
if mysql_cmd "$ip" "ssl_test_user" "ssl_test" ${ssl_mode_opt:-} --ssl-ca=${ca_cert_path} -e 'show status like "Ssl_cipher" \G' | grep 'Value: [A-Z][A-Z0-9-]*' ; then
echo " Success!"
rm -rf ${test_app_dir}
else
echo " FAIL!"
mysql_cmd "$ip" "ssl_test_user" "ssl_test" --ssl-ca=${ca_cert_path} -e 'show status like "%ssl%" \G'
return 1
fi
# Clear the global variable content after we are done using it
CONTAINER_EXTRA_ARGS=""
}
function run_general_tests() {
# Set lower buffer pool size to avoid running out of memory.
export CONTAINER_ARGS="run-mysqld --innodb_buffer_pool_size=5242880"
# Normal tests
USER=user PASS=pass run_tests no_root
USER=user1 PASS=pass1 ROOT_PASS=r00t run_tests root
# Test with arbitrary uid for the container
DOCKER_ARGS="--user 12345" USER=user PASS=pass run_tests no_root_altuid
DOCKER_ARGS="--user 12345" USER=user1 PASS=pass1 ROOT_PASS=r00t run_tests root_altuid
}
function get_previous_major_version() {
case "${1}" in
5.5) echo "5.1" ;;
5.6) echo "5.5" ;;
5.7) echo "5.6" ;;
8.0) echo "5.7" ;;
10.0) echo "5.5" ;;
10.1) echo "10.0" ;;
10.2) echo "10.1" ;;
10.3) echo "10.2" ;;
*) echo "Non expected version '${1}'" ; return 1 ;;
esac
}
function run_upgrade_test() {
local tmpdir=$(mktemp -d)
echo " Testing upgrade of the container image"
mkdir "${tmpdir}/data" && chmod -R a+rwx "${tmpdir}"
# Create MySQL container with persistent volume and set the version from too old version
local datadir=${tmpdir}/data
create_container "testupg1" -e MYSQL_USER=user -e MYSQL_PASSWORD=foo \
-e MYSQL_DATABASE=db -v ${datadir}:/var/lib/mysql/data:Z
test_connection testupg1 user foo
docker stop $(ct_get_cid testupg1) >/dev/null
# Simulate datadir without version information
rm -f ${datadir}/mysql_upgrade_info
echo " Testing upgrade from data without version"
# This should work, but warning should be printed
create_container "testupg2" -e MYSQL_USER=user -e MYSQL_PASSWORD=foo \
-e MYSQL_DATABASE=db -v ${datadir}:/var/lib/mysql/data:Z
test_connection testupg2 user foo
docker stop $(ct_get_cid testupg2) >/dev/null
# Check whether some information is provided
if ! docker logs $(ct_get_cid testupg2) 2>&1 | grep -e 'Version of the data could not be determined' &>/dev/null ; then
echo "Information about missing version file is not available in the logs"
return 1
fi
# Check whether upgrade did not happen
if docker logs $(ct_get_cid testupg2) 2>&1 | grep -e 'Running mysql_upgrade' &>/dev/null ; then
echo "Upgrade should not be run when information about version is missing"
return 1
fi
# Create version file that is too old
echo " Testing upgrade from too old data"
echo "5.0.12" >${datadir}/mysql_upgrade_info
# Create another container with same data and upgrade set to 'upgrade-auto'
assert_container_creation_fails -e MYSQL_USER=user -e MYSQL_PASSWORD=foo \
-e MYSQL_DATABASE=db -v ${datadir}:/var/lib/mysql/data:Z -e MYSQL_DATADIR_ACTION=upgrade-auto 2>/dev/null
# Create version file that we can upgrade from
echo " Testing upgrade from previous version"
echo "$(get_previous_major_version ${VERSION}).12" >${datadir}/mysql_upgrade_info
# Create another container with same data and upgrade set to 'upgrade-aauto'
create_container "testupg3" -e MYSQL_USER=user -e MYSQL_PASSWORD=foo \
-e MYSQL_DATABASE=db -v ${datadir}:/var/lib/mysql/data:Z -e MYSQL_DATADIR_ACTION=upgrade-auto
test_connection testupg3 user foo
docker stop $(ct_get_cid testupg3) >/dev/null
# Check whether some upgrade happened
if ! docker logs $(ct_get_cid testupg3) 2>&1 | grep -qe 'Running mysql_upgrade' ; then
echo "Upgrade did not happen but it should when upgrading from previous version"
docker logs $(ct_get_cid testupg3)
return 1
fi
# Create version file that we don't need to upgrade from
echo " Testing upgrade from the same version"
echo "${VERSION}.12" >${datadir}/mysql_upgrade_info
# Create another container with same data and upgrade set to 'upgrade-aauto'
create_container "testupg4" -e MYSQL_USER=user -e MYSQL_PASSWORD=foo \
-e MYSQL_DATABASE=db -v ${datadir}:/var/lib/mysql/data:Z -e MYSQL_DATADIR_ACTION=upgrade-auto
test_connection testupg4 user foo
docker stop $(ct_get_cid testupg4) >/dev/null
# Check whether some upgrade happened
if docker logs $(ct_get_cid testupg4) 2>&1 | grep -e 'Running mysql_upgrade' &>/dev/null ; then
echo "Upgrade happened but it should not when upgrading from current version"
return 1
fi
# Create second container with same data and upgrade set to 'analyze'
echo " Testing running --analyze"
create_container "testupg5" -e MYSQL_USER=user -e MYSQL_PASSWORD=foo \
-e MYSQL_DATABASE=db -v ${datadir}:/var/lib/mysql/data:Z -e MYSQL_DATADIR_ACTION=analyze
test_connection testupg5 user foo
docker stop $(ct_get_cid testupg5) >/dev/null
# Check whether analyze happened
if ! docker logs $(ct_get_cid testupg5) 2>&1 | grep -e '--analyze --all-databases' &>/dev/null ; then
echo "Analyze did not happen but it should"
return 1
fi
# Create another container with same data and upgrade set to 'optimize'
echo " Testing running --optimize"
create_container "testupg6" -e MYSQL_USER=user -e MYSQL_PASSWORD=foo \
-e MYSQL_DATABASE=db -v ${datadir}:/var/lib/mysql/data:Z -e MYSQL_DATADIR_ACTION=optimize
test_connection testupg6 user foo
docker stop $(ct_get_cid testupg6) >/dev/null
# Check whether optimize happened
if ! docker logs $(ct_get_cid testupg6) 2>&1 | grep -e '--optimize --all-databases' &>/dev/null ; then
echo "Optimize did not happen but it should"
return 1
fi
# Create version file that we cannot upgrade from
echo " Testing upgrade from the future version"
echo "20.1.12" >${datadir}/mysql_upgrade_info
assert_container_creation_fails -e MYSQL_USER=user -e MYSQL_PASSWORD=foo \
-e MYSQL_DATABASE=db -v ${datadir}:/var/lib/mysql/data:Z -e MYSQL_DATADIR_ACTION=upgrade-auto 2>/dev/null
echo " Upgrade tests succeeded!"
echo
}
function run_all_tests() {
for test_case in $TEST_LIST; do
echo "Running test $test_case for ${IMAGE_NAME}"
$test_case
done;
}
# Run the chosen tests
TEST_LIST=${@:-$TEST_LIST} run_all_tests
TESTSUITE_RESULT=0

1
test/run-openshift
View file

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

46
test/run-openshift-local-cluster
View file

@ -1,46 +0,0 @@
#!/bin/bash
#
# Test the MySQL image in OpenShift (local 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 MySQL in format of X.Y
# OS specifies RHEL version (e.g. OS=rhel7)
#
THISDIR=$(dirname ${BASH_SOURCE[0]})
source ${THISDIR}/test-lib-mysql.sh
set -eo nounset
trap ct_os_cleanup EXIT SIGINT
ct_os_check_compulsory_vars
ct_os_cluster_up
test_mysql_pure_image "${IMAGE_NAME}"
test_mysql_template "${IMAGE_NAME}"
# TODO: Can we make the build against examples inside the same PR?
test_mysql_s2i "${IMAGE_NAME}" "https://github.com/sclorg/mysql-container.git" test/test-app
# test with the just built image and an integrated template
test_mysql_integration "${IMAGE_NAME}" "${VERSION}" mysql
# test with a released image and an integrated template
if [ "${OS}" == "rhel7" ] ; then
PUBLIC_IMAGE_NAME=${PUBLIC_IMAGE_NAME:-${REGISTRY:-registry.access.redhat.com/}rhscl/${BASE_IMAGE_NAME}-${VERSION//./}-rhel7}
else
PUBLIC_IMAGE_NAME=${PUBLIC_IMAGE_NAME:-${REGISTRY:-}centos/${BASE_IMAGE_NAME}-${VERSION//./}-centos7}
fi
export CT_SKIP_UPLOAD_IMAGE=true
test_mysql_integration mysql "${VERSION}" "${PUBLIC_IMAGE_NAME}"
OS_TESTSUITE_RESULT=0
ct_os_cluster_down

30
test/run-openshift-remote-cluster
View file

@ -1,30 +0,0 @@
#!/bin/bash
#
# Test the MySQL 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 MySQL in format of X.Y
# OS specifies RHEL version (e.g. OS=rhel7)
#
THISDIR=$(dirname ${BASH_SOURCE[0]})
source ${THISDIR}/test-lib-mysql.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_mysql_integration mysql ${VERSION} "registry.access.redhat.com/${IMAGE_NAME}"
OS_TESTSUITE_RESULT=0

3
test/test-app/mysql-cfg/myconfig.cnf
View file

@ -1,3 +0,0 @@
[mysqld]
stored_program_cache = 524288

4
test/test-app/mysql-data/init.sql
View file

@ -1,4 +0,0 @@
CREATE TABLE products (id INTEGER, name VARCHAR(256), price FLOAT, variant INTEGER);
CREATE TABLE products_variant (id INTEGER, name VARCHAR(256));
INSERT INTO products_variant (id, name) VALUES ('1', 'blue'), ('2', 'green');

17
test/test-app/mysql-init/80-add-arbitrary-users.sh
View file

@ -1,17 +0,0 @@
create_arbitrary_users() {
# Do not care what option is compulsory here, just create what is specified
log_info "Creating user specified by MYSQL_OPERATIONS_USER (${MYSQL_OPERATIONS_USER}) ..."
mysql $mysql_flags <<EOSQL
CREATE USER '${MYSQL_OPERATIONS_USER}'@'%' IDENTIFIED BY '${MYSQL_OPERATIONS_PASSWORD}';
EOSQL
log_info "Granting privileges to user ${MYSQL_OPERATIONS_USER} for ${MYSQL_DATABASE} ..."
mysql $mysql_flags <<EOSQL
GRANT ALL ON \`${MYSQL_DATABASE}\`.* TO '${MYSQL_OPERATIONS_USER}'@'%' ;
FLUSH PRIVILEGES ;
EOSQL
}
if ! [ -v MYSQL_RUNNING_AS_SLAVE ]; then
create_arbitrary_users
fi

12
test/test-app/mysql-init/90-init-db.sh
View file

@ -1,12 +0,0 @@
init_arbitrary_database() {
local thisdir
local init_data_file
thisdir=$(dirname ${BASH_SOURCE[0]})
init_data_file=$(readlink -f ${thisdir}/../mysql-data/init.sql)
log_info "Initializing the arbitrary database from file ${init_data_file}..."
mysql $mysql_flags ${MYSQL_DATABASE} < ${init_data_file}
}
if ! [ -v MYSQL_RUNNING_AS_SLAVE ] && $MYSQL_DATADIR_FIRST_INIT ; then
init_arbitrary_database
fi

10
test/test-app/mysql-pre-init/80-check-arbitrary-users.sh
View file

@ -1,10 +0,0 @@
check_arbitrary_users() {
if ! [[ -v MYSQL_OPERATIONS_USER && -v MYSQL_OPERATIONS_PASSWORD && -v MYSQL_DATABASE ]]; then
echo "You need to specify all these variables: MYSQL_OPERATIONS_USER, MYSQL_OPERATIONS_PASSWORD, and MYSQL_DATABASE"
return 1
fi
}
if ! [ -v MYSQL_RUNNING_AS_SLAVE ]; then
check_arbitrary_users
fi

130
test/test-lib-mysql.sh
View file

@ -1,130 +0,0 @@
#!/bin/bash
#
# Functions for tests for the MySQL 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 check_mysql_os_service_connection() {
local util_image_name="${1}" ; shift
local service_name="${1}" ; shift
local user="${1}" ; shift
local pass="${1}" ; shift
local timeout="${1:-60}" ; shift || :
local pod_ip=$(ct_os_get_service_ip ${service_name})
: " Service ${service_name} check ..."
local cmd="echo 'SELECT 42 as testval\g' | mysql --connect-timeout=15 -h ${pod_ip} -u${user} -p${pass}"
local expected_value='^42'
local output
local ret
SECONDS=0
echo -n "Waiting for ${service_name} service becoming ready ..."
while true ; do
output=$(docker run --rm ${util_image_name} bash -c "${cmd}" || :)
echo "${output}" | grep -qe "${expected_value}" && ret=0 || ret=1
if [ ${ret} -eq 0 ] ; then
echo " PASS"
return 0
fi
echo -n "."
[ ${SECONDS} -gt ${timeout} ] && break
sleep 3
done
echo " FAIL"
return 1
}
function test_mysql_pure_image() {
local image_name=${1:-centos/mysql-80-centos7}
local image_name_no_namespace=${image_name##*/}
local service_name=${image_name_no_namespace}
ct_os_new_project
# Create a specific imagestream tag for the image so that oc cannot use anything else
ct_os_upload_image "${image_name}" "$image_name_no_namespace:testing"
ct_os_deploy_pure_image "$image_name_no_namespace:testing" \
--name "${service_name}" \
--env MYSQL_ROOT_PASSWORD=test
ct_os_wait_pod_ready "${service_name}" 60
check_mysql_os_service_connection "${image_name}" "${service_name}" root test
ct_os_delete_project
}
function test_mysql_template() {
local image_name=${1:-centos/mysql-80-centos7}
local image_name_no_namespace=${image_name##*/}
local service_name=${image_name_no_namespace}
ct_os_new_project
ct_os_upload_image "${image_name}" "mysql:$VERSION"
ct_os_deploy_template_image ${THISDIR}/mysql-ephemeral-template.json \
NAMESPACE="$(oc project -q)" \
MYSQL_VERSION="$VERSION" \
DATABASE_SERVICE_NAME="${service_name}" \
MYSQL_USER=testu \
MYSQL_PASSWORD=testp \
MYSQL_DATABASE=testdb
ct_os_wait_pod_ready "${service_name}" 60
check_mysql_os_service_connection "${image_name}" "${service_name}" testu testp
ct_os_delete_project
}
function test_mysql_s2i() {
local image_name=${1:-centos/mysql-80-centos7}
local app=${2:-https://github.com/sclorg/mysql-container.git}
local context_dir=${3:-test/test-app}
local image_name_no_namespace=${image_name##*/}
local service_name="${image_name_no_namespace}-testing"
ct_os_new_project
# Create a specific imagestream tag for the image so that oc cannot use anything else
ct_os_upload_image "${image_name}" "$image_name_no_namespace:testing"
ct_os_deploy_s2i_image "$image_name_no_namespace:testing" "${app}" \
--context-dir="${context_dir}" \
--name "${service_name}" \
--env MYSQL_ROOT_PASSWORD=test \
--env MYSQL_OPERATIONS_USER=testo \
--env MYSQL_OPERATIONS_PASSWORD=testo \
--env MYSQL_DATABASE=testopdb \
--env MYSQL_USER=testnormal \
--env MYSQL_PASSWORD=testnormal
ct_os_wait_pod_ready "${service_name}" 60
check_mysql_os_service_connection "${image_name}" "${service_name}" testo testo 120
ct_os_delete_project
}
function test_mysql_integration() {
local image_name=$1
local VERSION=$2
local import_image=$3
local service_name=${import_image##*/}
ct_os_template_exists mysql-ephemeral && t=mysql-ephemeral || t=mysql-persistent
ct_os_test_template_app_func "${image_name}" \
"${t}" \
"${service_name}" \
"ct_os_check_cmd_internal '${import_image}' '${service_name}' \"echo 'SELECT 42 as testval\g' | mysql --connect-timeout=15 -h <IP> testdb -utestu -ptestp\" '^42' 120" \
"-p MYSQL_VERSION=${VERSION} \
-p DATABASE_SERVICE_NAME="${service_name}-testing" \
-p MYSQL_USER=testu \
-p MYSQL_PASSWORD=testp \
-p MYSQL_DATABASE=testdb" "" "${import_image}"
}

1040
test/test-lib-openshift.sh
View file

File diff suppressed because it is too large Load diff

653
test/test-lib.sh
View file

@ -1,653 +0,0 @@
# shellcheck shell=bash
#
# 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
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
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-}"
# we really work with CONTAINER_ARGS as with a string
# shellcheck disable=SC2124
CONTAINER_ARGS="$@"
if ct_create_container "$cid_file" ; then
local cid
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
[ -n "$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
# shellcheck disable=SC2086
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
tmpdir=$(mktemp -d)
local f
: " Testing documentation in the container image"
# Extract the help files from the container
# shellcheck disable=SC2043
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 ! grep -F -q -e "${term}" "${tmpdir}/$(basename "${f}")" ; 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
tmpdir=$(mktemp -d)
: " Testing npm in the container image"
local cid_file="${tmpdir}/cid"
if ! docker run --rm "${IMAGE_NAME}" /bin/bash -c "npm --version" >"${tmpdir}/version" ; then
echo "ERROR: 'npm --version' does not work inside the image ${IMAGE_NAME}." >&2
return 1
fi
# shellcheck disable=SC2046
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
if ! docker exec "$(cat "$cid_file")" /bin/bash -c "npm --verbose install jquery && test -f node_modules/jquery/src/jquery.js" >"${tmpdir}/jquery" 2>&1 ; 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"
# shellcheck source=/dev/null
[ -f "test/$test_case" ] && source "test/$test_case"
# shellcheck source=/dev/null
[ -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
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
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=$(tail -c 3 "${response_file}")
if [ "${response_code}" -eq "${expected_code}" ]; then
result=0
fi
grep -qP -e "${body_regexp}" "${response_file}" || 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 ] || [ "${attempt}" -gt "${ignore_error_attempts}" ] || [ "${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.redhat.io
;;
*)
registry=docker.io
;;
esac
echo "$registry"
}
# ct_get_public_image_name OS BASE_IMAGE_NAME VERSION
# ----------------
# Transform the arguments into public image name
# Argument: OS - string containing the os version
# Argument: BASE_IMAGE_NAME - string containing the base name of the image as defined in the Makefile
# Argument: VERSION - string containing the version of the image as defined in the Makefile
ct_get_public_image_name() {
local os=$1; shift
local base_image_name=$1; shift
local version=$1; shift
local public_image_name
local registry
registry=$(ct_registry_from_os "$os")
if [ "x$os" == "xrhel7" ]; then
public_image_name=$registry/rhscl/$base_image_name-${version//./}-rhel7
elif [ "x$os" == "xrhel8" ]; then
public_image_name=$registry/rhel8/$base_image_name-${version//./}
elif [ "x$os" == "xcentos7" ]; then
public_image_name=$registry/centos/$base_image_name-${version//./}-centos7
fi
echo "$public_image_name"
}
# 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"
echo "ADD artifacts.tar /tmp/artifacts"
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
# shellcheck disable=SC2086
docker build $mount_options -f "$df_name" --no-cache=true -t "$dst_image" .
)
}
# ct_check_image_availability PUBLIC_IMAGE_NAME
# ----------------------------
# Pull an image from the public repositories to see if the image is already available.
# Argument: PUBLIC_IMAGE_NAME - string containing the public name of the image to pull
ct_check_image_availability() {
local public_image_name=$1;
# Try pulling the image to see if it is accessible
if ! docker pull "$public_image_name" &>/dev/null; then
echo "$public_image_name could not be downloaded via 'docker'"
return 1
fi
}
# vim: set tabstop=2:shiftwidth=2:expandtab: