update master hashes

This reverts commit 5d9488e143.

Dockerfile

@@ -1,88 +1,41 @@
-# Container artifact for the PostgreSQL module
-
-# This should probably rather be something like...:
-# FROM registry.fedoraproject.org/module-base-runtime:26
-# ...and probably would:
-# - not have any repositories configured
-# - need a shared-userspace module repo enabled
 FROM baseruntime/baseruntime:latest
 
-# PostgreSQL container image
-# Exposed ports:
-#  * 5432/tcp - postgres
+# PostgreSQL image for OpenShift.
 # Volumes:
-#  * /var/lib/psql/data - Database cluster for PostgreSQL
+#  * /var/lib/psql/data   - Database cluster for PostgreSQL
+# Environment:
+#  * $POSTGRESQL_USER     - Database user name
+#  * $POSTGRESQL_PASSWORD - User's password
+#  * $POSTGRESQL_DATABASE - Name of the database to create
+#  * $POSTGRESQL_ADMIN_PASSWORD (Optional) - Password for the 'postgres'
+#                           PostgreSQL administrative account
 
-
-ENV NAME=postgresql \
-    VERSION=0 \
-    RELEASE=1 \
-    ARCH=x86_64 \
-    LANG=C.UTF-8 \
-    LC_ALL=C.UTF-8 \
-    POSTGRESQL_VERSION=9.6 \
+ENV POSTGRESQL_VERSION=9.5 \
     HOME=/var/lib/pgsql \
-    PGUSER=postgres \
-    POSTGRESQL_MODULE_HASH=d87b0b15567e47f3
+    PGUSER=postgres
 
-LABEL summary = "PostgreSQL is an object-relational DBMS." \
-      name = "$FGC/$NAME" \
-      version = "$VERSION" \
-      release="$RELEASE.$DISTTAG"  \
-      architecture = "$ARCH" \
-      maintainer = "Nils Philippsen <nils@redhat.com>" \
-      description = "PostgreSQL is an advanced Object-Relational database management system (DBMS). This container contains the programs needed to create and run a PostgreSQL server, which will in turn allow you to create and maintain PostgreSQL databases." \
-      vendor="Fedora Project" \
-      com.redhat.component="$NAME" \
-      org.fedoraproject.component="postgresql" \
-      authoritative-source-url="registry.fedoraproject.org" \
-      usage="docker run -v <dbroot_path>:/var/lib/pgsql:Z -p 5432:5432 -e POSTGRESQL_USER=<user> -e POSTGRESQL_PASSWORD=<password> -e POSTGRESQL_DATABASE=<database> modularitycontainers/postgresql" \
-      io.k8s.description = "PostgreSQL is an advanced Object-Relational database management system (DBMS). This container contains the programs needed to create and run a PostgreSQL server, which will in turn allow you to create and maintain PostgreSQL databases." \
-      io.k8s.display-name="PostgreSQL ${POSTGRESQL_VERSION}" \
-      io.openshift.tags="database,postgresql,postgresql96" \
-      io.openshift.expose-services="5432/tcp:postgres"
+LABEL io.k8s.description="PostgreSQL is an advanced Object-Relational database management system" \
+      io.k8s.display-name="PostgreSQL 9.5" \
+      io.openshift.expose-services="5432:postgresql" \
+      io.openshift.tags="database,postgresql,postgresql95" \
+      com.redhat.component="postgresql" \
+      maintainer="Pavel Raiskup <praiskup@redhat.com>" \
+      name="$FCG/postgresql" \
+      version="0" \
+      release="1.$DISTTAG" \
+      architecture="x86_64" \
+      usage="Run without arguments to get usage info." \
+      help="/help.1"
 
 EXPOSE 5432
 
 ADD root /
 
-COPY module-postgresql.repo.in /tmp/module-postgresql.repo.in
-COPY run_tests.sh /usr/bin/run_tests.sh
+COPY repos/* /etc/yum.repos.d/
 
-# Install the postgresql server component.
-#
-# This image must forever use UID 26 for postgres user so our volumes are
-# safe in the future. This should *never* change, the last test is there
-# to make sure of that.
-
-# Notes about the below:
-# - first sed cmd: don't ask
-# - rpm -e ... microdnf install systemd: workaround to missing
-#   microdnf downgrade/distro-sync
-# - Update packages so everything available is current
-# - Need to have charset files, disable normal repo(s), enable module repo(s)
-# ORCHESTRATION:
-# - Newer versions of the shared-userspace module are supposed to have
-#   findutils, not there yet
-# - gettext: /usr/bin/envsubst
-# - no working python module yet
-
-RUN \
-    sed -i 's|/jkaluza/|/ralph/|g' /etc/yum.repos.d/build.repo && \
-    rpm -e --justdb --nodeps systemd-libs && \
-    microdnf install -y --setopt=tsflags=nodocs systemd && \
-    # microdnf update -y --setopt=tsflags=nodocs && \
-    # microdnf install -y glibc-locale-source && \
-    microdnf install -y findutils && \
-    microdnf install -y gettext && \
-    # microdnf install -y nss_wrapper && \
-    # microdnf install -y /usr/bin/python && \
-    sed 's|@POSTGRESQL_MODULE_HASH@|'${POSTGRESQL_MODULE_HASH}'|g; s|${basearch}|'${ARCH}'|g' < /tmp/module-postgresql.repo.in > /etc/yum.repos.d/module-postgresql.repo && rm -f /tmp/module-postgresql.repo.in && \
-    INSTALL_PKGS="postgresql postgresql-server" && \
-    microdnf install -y --setopt=tsflags=nodocs $INSTALL_PKGS && \
-    rpm -V $INSTALL_PKGS && \
-    microdnf -y clean all && \
-    # localedef -f UTF-8 -i en_US en_US.UTF-8 && \
+RUN microdnf --nodocs --enablerepo postgresql install -y  postgresql postgresql-server postgresql-contrib && \
+    microdnf --nodocs --enablerepo fedora install -y rsync tar gettext bind-utils nss_wrapper findutils python && \
+    microdnf clean all && \
     test "$(id postgres)" = "uid=26(postgres) gid=26(postgres) groups=26(postgres)" && \
     mkdir -p /var/lib/pgsql/data && \
     /usr/libexec/fix-permissions /var/lib/pgsql && \
@@ -91,9 +44,8 @@ RUN \
 # Get prefix path and path to scripts rather than hard-code them in scripts
 ENV CONTAINER_SCRIPTS_PATH=/usr/share/container-scripts/postgresql
 
-VOLUME ["/var/lib/pgsql"]
+VOLUME ["/var/lib/pgsql/data"]
 
 USER 26
 
-ENTRYPOINT ["container-entrypoint"]
 CMD ["run-postgresql"]

Makefile

@@ -1,4 +1,4 @@
-IMAGE_NAME = modularitycontainers/postgresql
+IMAGE_NAME = postgresql
 
 MODULEMDURL=file://postgresql.yaml
 
@@ -8,7 +8,7 @@ build:
 	docker build --tag=$(IMAGE_NAME) .
 
 run: build
-	docker run -it -p 80:80 $(IMAGE_NAME)
+	docker run -d $(IMAGE_NAME)
 
 test: build
 	cd tests; MODULE=docker MODULEMD=$(MODULEMDURL) URL="docker=$(IMAGE_NAME)" make all

README.md

@@ -1,41 +0,0 @@
-# PostgreSQL
-
-PostgreSQL is an object-relational Database Management System.
-
-This is based on the SCL container image for version 9.5 at:
-
-https://github.com/sclorg/postgresql-container
-
-## Configuration
-
-You must either specify the following environment variables:
-
-* POSTGRESQL_USER
-* POSTGRESQL_PASSWORD
-* POSTGRESQL_DATABASE
-
-Or the following environment variable:
-
-* POSTGRESQL_ADMIN_PASSWORD
-
-Or both.
-
-Optional settings:
-
-* POSTGRESQL_MAX_CONNECTIONS (default: 100)
-* POSTGRESQL_MAX_PREPARED_TRANSACTIONS (default: 0)
-* POSTGRESQL_SHARED_BUFFERS (default: 32MB)
-
-## Running in docker
-
-```
-docker run -v <dbroot_path>:/var/lib/pgsql:Z -p 5432:5432 -e POSTGRESQL_USER=<user> -e POSTGRESQL_PASSWORD=<password> -e POSTGRESQL_DATABASE=<database> modularitycontainers/postgresql
-```
-
-Substitute these placeholders with real values:
-
-* `dbroot_path` - path to the database root on the host which should be mounted
-  on `/var/lib/pgsql` in the container. Note that the `postgres` user (uid 26)
-  needs to be able to read and write in that directory.
-* `user`, `password`, `database` - details with which a database and user
-  should be created if the database cluster directory isn't initialized yet.

module-postgresql.repo.in

@@ -1,5 +0,0 @@
-[module-postgresql]
-name=Repository for the PostgreSQL module
-baseurl=https://kojipkgs.fedoraproject.org/repos/module-@POSTGRESQL_MODULE_HASH@-build/latest/${basearch}/
-enabled=1
-gpgcheck=0

postgresql.yaml

@@ -1,81 +1,41 @@
 document: modulemd
 version: 1
 data:
-  # name, stream, version are filled in by the build system
-  #name: ""
-  #stream: ""
-  #version: 0
-  summary: 'The programs needed to create and run a PostgreSQL server'
-  description: |-
-    PostgreSQL is an advanced Object-Relational database management system
-    (DBMS). The postgresql-server package contains the programs needed to
-    create and run a PostgreSQL server, which will in turn allow you to create
-    and maintain PostgreSQL databases.
+  summary: postgresql module
+  description: This postgresql module has been generated.
   license:
-    module:
-      - MIT
-    content:
-      - PostgreSQL
+    module: [ MIT ]
   dependencies:
     buildrequires:
-      base-runtime: f26
-      common-build-dependencies: f26
-      common-build-dependencies-bootstrap: f26
-      shared-userspace: f26
-      perl: f26
+      bootstrap: master
     requires:
-      base-runtime: f26
+      platform: master
+  references:
+    community: https://docs.pagure.org/modularity/
+    documentation: https://github.com/modularity-modules/postgresql
+    tracker: https://github.com/modularity-modules/postgresql
   api:
     rpms:
       - postgresql
   profiles:
     default:
       rpms:
-        - postgresql-server 
+        - postgresql-server
+    server:
+      rpms:
+        - postgresql-server
     client:
       rpms:
         - postgresql
   filter: {}
   components:
     rpms:
-      # part of base-runtime:
-      # gettext
-      # part of common-build-dependencies:
-      # autoconf(uuid), multilib-rpm-config, docbook-utils
-      # part of shared-userspace:
-      # docbook-dtds, docbook-style-dsssl, libxslt, perl-SGMLSpm, python2, tcl
-      oniguruma:
-        rationale: 'Build dependency (for slang)'
-        ref: f26
-      perl-Data-UUID:
-        rationale: 'Build dependency (for uuid)'
-        ref: f26
-      rsh:
-        rationale: 'Build dependency (for lynx)'
-        ref: f26
-      telnet:
-        rationale: 'Build dependency (for lynx)'
-        ref: f26
-      slang:
-        buildorder: 1
-        rationale: 'Build dependency (for lynx)'
-        ref: f26
-      uuid:
-        buildorder: 1
-        rationale: 'Build dependency (for postgresql).'
-        ref: f26
-      lynx:
-        buildorder: 2
-        rationale: >-
-          Build dependency (for postgresql),
-        ref: f26
+      # postgresql-10.0-3.fc28
       postgresql:
-        buildorder: 3
-        rationale: 'The API we want to provide.'
-        # This branch doesn't BR: systemtap(-devel), elinks which pulls in
-        # loads of other junk
-        ref: private-f27-modules
-      tcl-pgtcl:
-        buildorder: 4
-        rationale: 'Runtime dependency (for postgresql-pltcl)'
-        ref: f26
+        rationale: Generated.
+        ref: 07894e0da4b994092abd0084fba982e075ccf3f3
+      # uuid-1.6.2-39.fc27
+      uuid:
+        rationale: Generated.
+        ref: 43c916caff937bdf8a97ded1abff3e01df4895f4
+

repos/fedora.repo

@@ -0,0 +1,5 @@
+[fedora]
+name=fedora
+baseurl=https://mirrors.nic.cz/fedora/linux/development/26/Everything/x86_64/os/
+enabled=0
+

repos/postgresql.repo

@@ -0,0 +1,4 @@
+[postgresql]
+name=postgresql
+baseurl=https://kojipkgs.fedoraproject.org/repos/module-5a0a295c9673c2a1/latest/x86_64/
+enabled=0

root/help.1

@@ -0,0 +1,190 @@
+.\"t
+.\" WARNING: Do not edit this file manually, it is generated from README.md automatically.
+.\"
+.\"t
+.\" Automatically generated by Pandoc 1.16.0.2
+.\"
+.TH "POSTGRESQL\-95\-RHEL7" "1" "February 22, 2017" "Container Image Pages" ""
+.hy
+.SH PostgreSQL Docker image
+.PP
+This repository contains Dockerfiles for PostgreSQL images for general
+usage and OpenShift.
+Users can choose between RHEL and CentOS based images.
+.SS Environment variables and volumes
+.PP
+The image recognizes the following environment variables that you can
+set during initialization by passing \f[C]\-e\ VAR=VALUE\f[] to the
+Docker run command.
+.PP
+.TS
+tab(@);
+lw(26.7n) lw(43.3n).
+T{
+Variable name
+T}@T{
+Description
+T}
+_
+T{
+\f[C]POSTGRESQL_USER\f[]
+T}@T{
+User name for PostgreSQL account to be created
+T}
+T{
+\f[C]POSTGRESQL_PASSWORD\f[]
+T}@T{
+Password for the user account
+T}
+T{
+\f[C]POSTGRESQL_DATABASE\f[]
+T}@T{
+Database name
+T}
+T{
+\f[C]POSTGRESQL_ADMIN_PASSWORD\f[]
+T}@T{
+Password for the \f[C]postgres\f[] admin account (optional)
+T}
+.TE
+.PP
+The following environment variables influence the PostgreSQL
+configuration file.
+They are all optional.
+.PP
+.TS
+tab(@);
+lw(15.7n) lw(37.6n) lw(16.7n).
+T{
+Variable name
+T}@T{
+Description
+T}@T{
+Default
+T}
+_
+T{
+\f[C]POSTGRESQL_MAX_CONNECTIONS\f[]
+T}@T{
+The maximum number of client connections allowed
+T}@T{
+100
+T}
+T{
+\f[C]POSTGRESQL_MAX_PREPARED_TRANSACTIONS\f[]
+T}@T{
+Sets the maximum number of transactions that can be in the "prepared"
+state.
+If you are using prepared transactions, you will probably want this to
+be at least as large as max_connections
+T}@T{
+0
+T}
+T{
+\f[C]POSTGRESQL_SHARED_BUFFERS\f[]
+T}@T{
+Sets how much memory is dedicated to PostgreSQL to use for caching data
+T}@T{
+32M
+T}
+T{
+\f[C]POSTGRESQL_EFFECTIVE_CACHE_SIZE\f[]
+T}@T{
+Set to an estimate of how much memory is available for disk caching by
+the operating system and within the database itself
+T}@T{
+128M
+T}
+.TE
+.PP
+You can also set the following mount points by passing the
+\f[C]\-v\ /host:/container\f[] flag to Docker.
+.PP
+.TS
+tab(@);
+l l.
+T{
+Volume mount point
+T}@T{
+Description
+T}
+_
+T{
+\f[C]/var/lib/pgsql/data\f[]
+T}@T{
+PostgreSQL database cluster directory
+T}
+.TE
+.PP
+\f[B]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.\f[]
+.SS Usage
+.PP
+For this, we will assume that you are using the
+\f[C]openshift/postgresql\-92\-centos7\f[] image.
+If you want to set only the mandatory environment variables and not
+store the database in a host directory, execute the following command:
+.IP
+.nf
+\f[C]
+$\ docker\ run\ \-d\ \-\-name\ postgresql_database\ \-e\ POSTGRESQL_USER=user\ \-e\ POSTGRESQL_PASSWORD=pass\ \-e\ POSTGRESQL_DATABASE=db\ \-p\ 5432:5432\ openshift/postgresql\-92\-centos7
+\f[]
+.fi
+.PP
+This will create a container named \f[C]postgresql_database\f[] running
+PostgreSQL with database \f[C]db\f[] and user with credentials
+\f[C]user:pass\f[].
+Port 5432 will be exposed and mapped to the host.
+If you want your database to be persistent across container executions,
+also add a \f[C]\-v\ /host/db/path:/var/lib/pgsql/data\f[] argument.
+This will be the PostgreSQL database cluster directory.
+.PP
+If the database cluster directory is not initialized, the entrypoint
+script will first run
+\f[C]initdb\f[] (http://www.postgresql.org/docs/9.2/static/app-initdb.html)
+and setup necessary database users and passwords.
+After the database is initialized, or if it was already present,
+\f[C]postgres\f[] (http://www.postgresql.org/docs/9.2/static/app-postgres.html)
+is executed and will run as PID 1.
+You can stop the detached container by running
+\f[C]docker\ stop\ postgresql_database\f[].
+.SS PostgreSQL auto\-tuning
+.PP
+When the PostgreSQL image is run with the \f[C]\-\-memory\f[] parameter
+set and if there are no values provided for
+\f[C]POSTGRESQL_SHARED_BUFFERS\f[] and
+\f[C]POSTGRESQL_EFFECTIVE_CACHE_SIZE\f[] those values are automatically
+calculated based on the value provided in the \f[C]\-\-memory\f[]
+parameter.
+.PP
+The values are calculated based on the
+upstream (https://wiki.postgresql.org/wiki/Tuning_Your_PostgreSQL_Server)
+formulas.
+For the \f[C]shared_buffers\f[] we use 1/4 of given memory and for the
+\f[C]effective_cache_size\f[] we set the value to 1/2 of the given
+memory.
+.SS PostgreSQL admin account
+.PP
+The admin account \f[C]postgres\f[] has no password set by default, only
+allowing local connections.
+You can set it by setting the \f[C]POSTGRESQL_ADMIN_PASSWORD\f[]
+environment variable when initializing your container.
+This will allow you to login to the \f[C]postgres\f[] account remotely.
+Local connections will still not require a password.
+.SS Changing passwords
+.PP
+Since passwords are part of the image configuration, the only supported
+method to change passwords for the database user
+(\f[C]POSTGRESQL_USER\f[]) and \f[C]postgres\f[] admin user is by
+changing the environment variables \f[C]POSTGRESQL_PASSWORD\f[] and
+\f[C]POSTGRESQL_ADMIN_PASSWORD\f[], respectively.
+.PP
+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.
+.SH AUTHORS
+Red Hat.

root/usr/bin/cgroup-limits

@@ -1,99 +1,92 @@
-#!/bin/bash
+#!/usr/bin/python
 
-# Script for parsing cgroup information
-#
-# This script will read some limits from the cgroup system and parse
-# them, printing out "VARIABLE=VALUE" on each line for every limit that is
-# successfully read. Output of this script can be directly fed into
-# bash's export command. Recommended usage from a bash script:
-#
-#     set -o errexit
-#     export_vars=$(cgroup-limits) ; export $export_vars
-#
-# Variables currently supported:
-#     MAX_MEMORY_LIMIT_IN_BYTES
-#         Maximum possible limit MEMORY_LIMIT_IN_BYTES can have. This is
-#         currently a constant value of 9223372036854775807.
-#     MEMORY_LIMIT_IN_BYTES
-#         Maximum amount of user memory in bytes. If this value is set
-#         to the same value as MAX_MEMORY_LIMIT_IN_BYTES, it means that
-#         there is no limit set. The value is taken from
-#         /sys/fs/cgroup/memory/memory.limit_in_bytes
-#     RAM_SIZE_IN_BYTES
-#         Available memory in bytes. The value is taken from /proc/meminfo.
-#     NUMBER_OF_CORES
-#         Number of detected CPU cores that can be used. This value is
-#         calculated from /sys/fs/cgroup/cpuset/cpuset.cpus
-#     NO_MEMORY_LIMIT
-#         Set to "true" if MEMORY_LIMIT_IN_BYTES is so high that the caller
-#         can act as if no memory limit was set. Undefined otherwise.
+"""
+Script for parsing cgroup information
 
-get_memory_limit() {
-    local limit="$(cat /sys/fs/cgroup/memory/memory.limit_in_bytes)"
-    if [ $? -eq 0 ]; then
-        echo "$limit"
-    else
-        echo "Warning: Can't detect memory limit from cgroups" >&2
-    fi
-}
+This script will read some limits from the cgroup system and parse
+them, printing out "VARIABLE=VALUE" on each line for every limit that is
+successfully read. Output of this script can be directly fed into
+bash's export command. Recommended usage from a bash script:
 
-get_meminfo_ram_size() {
-    local limit="$(cat /proc/meminfo | while read key val unit rest; do if [ "$key" = "MemTotal:" ]; then echo "$val $unit"; break; fi; done)"
-    if [ $? -eq 0 ]; then
-        local val="${limit/ *}"
-        local unit="${limit/* }"
-        case "$unit" in
-            kB)
-                val=$(($val * 1024))
-                ;;
-            MB)
-                val=$(($val * 1024 * 1024))
-                ;;
-            GB)
-                val=$(($val * 1024 * 1024 * 1024))
-                ;;
-        esac
-        echo "$val"
-    else
-        echo "Warning: Can't detect RAM site from /proc/meminfo." >&2
-    fi
-}
+    set -o errexit
+    export_vars=$(cgroup-limits) ; export $export_vars
 
-get_number_of_cores() {
-    local core_count=0
-    local group
-    local sysfs_cpus="$(cat /sys/fs/cgroup/cpuset/cpuset.cpus)"
+Variables currently supported:
+    MAX_MEMORY_LIMIT_IN_BYTES
+        Maximum possible limit MEMORY_LIMIT_IN_BYTES can have. This is
+        currently constant value of 9223372036854775807.
+    MEMORY_LIMIT_IN_BYTES
+        Maximum amount of user memory in bytes. If this value is set
+        to the same value as MAX_MEMORY_LIMIT_IN_BYTES, it means that
+        there is no limit set. The value is taken from
+        /sys/fs/cgroup/memory/memory.limit_in_bytes
+    NUMBER_OF_CORES
+        Number of detected CPU cores that can be used. This value is
+        calculated from /sys/fs/cgroup/cpuset/cpuset.cpus
+    NO_MEMORY_LIMIT
+        Set to "true" if MEMORY_LIMIT_IN_BYTES is so high that the caller
+        can act as if no memory limit was set. Undefined otherwise.
+"""
 
-    if [ $? -eq 0 ]; then
-        for group in ${sysfs_cpus//,/ }; do
-            local from="${group%-*}"
-            local to="${group#*-}"
-            core_count=$(($core_count + $to - $from + 1))
-        done
-        echo "$core_count"
-    else
-        echo "Warning: Can't detect number of CPU cores from cgroups" >&2
-    fi
-}
+from __future__ import print_function
+import sys
 
-MAX_MEMORY_LIMIT_IN_BYTES=9223372036854775807
-MEMORY_LIMIT_IN_BYTES="$(get_memory_limit)"
-RAM_SIZE_IN_BYTES="$(get_meminfo_ram_size)"
-NUMBER_OF_CORES="$(get_number_of_cores)"
 
-echo "MAX_MEMORY_LIMIT_IN_BYTES=$MAX_MEMORY_LIMIT_IN_BYTES"
+def _read_file(path):
+    try:
+        with open(path, 'r') as f:
+            return f.read().strip()
+    except IOError:
+        return None
 
-if [ -n "$MEMORY_LIMIT_IN_BYTES" ]; then
-    echo "MEMORY_LIMIT_IN_BYTES=$MEMORY_LIMIT_IN_BYTES"
-    if [ "$MEMORY_LIMIT_IN_BYTES" -ge "$MAX_MEMORY_LIMIT_IN_BYTES" ]; then
-        echo "NO_MEMORY_LIMIT=true"
-    fi
-fi
 
-if [ -n "$RAM_SIZE_IN_BYTES" ]; then
-    echo "RAM_SIZE_IN_BYTES=$RAM_SIZE_IN_BYTES"
-fi
+def get_memory_limit():
+    """
+    Read memory limit, in bytes.
+    """
 
-if [ -n "$NUMBER_OF_CORES" ]; then
-    echo "NUMBER_OF_CORES=$NUMBER_OF_CORES"
-fi
+    limit = _read_file('/sys/fs/cgroup/memory/memory.limit_in_bytes')
+    if limit is None or not limit.isdigit():
+        print("Warning: Can't detect memory limit from cgroups",
+              file=sys.stderr)
+        return None
+    return int(limit)
+
+
+def get_number_of_cores():
+    """
+    Read number of CPU cores.
+    """
+
+    core_count = 0
+
+    line = _read_file('/sys/fs/cgroup/cpuset/cpuset.cpus')
+    if line is None:
+        print("Warning: Can't detect number of CPU cores from cgroups",
+              file=sys.stderr)
+        return None
+
+    for group in line.split(','):
+        core_ids = list(map(int, group.split('-')))
+        if len(core_ids) == 2:
+            core_count += core_ids[1] - core_ids[0] + 1
+        else:
+            core_count += 1
+
+    return core_count
+
+
+if __name__ == "__main__":
+    env_vars = {
+        "MAX_MEMORY_LIMIT_IN_BYTES": 9223372036854775807,
+        "MEMORY_LIMIT_IN_BYTES": get_memory_limit(),
+        "NUMBER_OF_CORES": get_number_of_cores()
+    }
+
+    env_vars = {k: v for k, v in env_vars.items() if v is not None}
+
+    if env_vars.get("MEMORY_LIMIT_IN_BYTES", 0) >= 92233720368547:
+        env_vars["NO_MEMORY_LIMIT"] = "true"
+
+    for key, value in env_vars.items():
+        print("{0}={1}".format(key, value))

root/usr/libexec/fix-permissions

@@ -1,5 +1,5 @@
 #!/bin/sh
-# Fix permissions on the given directory to allow group read/write of
+# Fix permissions on the given directory to allow group read/write of 
 # regular files and execute of directories.
 find "$1" -exec chown postgres {} \;
 find "$1" -exec chgrp 0 {} \;

root/usr/share/container-scripts/postgresql/common.sh

@@ -6,19 +6,14 @@ export POSTGRESQL_MAX_PREPARED_TRANSACTIONS=${POSTGRESQL_MAX_PREPARED_TRANSACTIO
 # limits are set).
 # Users can still override this by setting the POSTGRESQL_SHARED_BUFFERS
 # and POSTGRESQL_EFFECTIVE_CACHE_SIZE variables.
-if [[ "${NO_MEMORY_LIMIT:-}" == "true" || -z "${MEMORY_LIMIT_IN_BYTES:-}" || -z "${RAM_SIZE_IN_BYTES:-}" ]]; then
+if [[ "${NO_MEMORY_LIMIT:-}" == "true" || -z "${MEMORY_LIMIT_IN_BYTES}" ]]; then
     export POSTGRESQL_SHARED_BUFFERS=${POSTGRESQL_SHARED_BUFFERS:-32MB}
     export POSTGRESQL_EFFECTIVE_CACHE_SIZE=${POSTGRESQL_EFFECTIVE_CACHE_SIZE:-128MB}
 else
-    if [ "$MEMORY_LIMIT_IN_BYTES" -gt "$RAM_SIZE_IN_BYTES" ]; then
-        mem_limit="$RAM_SIZE_IN_BYTES"
-    else
-        mem_limit="$MEMORY_LIMIT_IN_BYTES"
-    fi
     # Use 1/4 of given memory for shared buffers
-    shared_buffers_computed="$(($mem_limit/1024/1024/4))MB"
+    shared_buffers_computed="$(($MEMORY_LIMIT_IN_BYTES/1024/1024/4))MB"
     # Setting effective_cache_size to 1/2 of total memory would be a normal conservative setting,
-    effective_cache="$(($mem_limit/1024/1024/2))MB"
+    effective_cache="$(($MEMORY_LIMIT_IN_BYTES/1024/1024/2))MB"
     export POSTGRESQL_SHARED_BUFFERS=${POSTGRESQL_SHARED_BUFFERS:-$shared_buffers_computed}
     export POSTGRESQL_EFFECTIVE_CACHE_SIZE=${POSTGRESQL_EFFECTIVE_CACHE_SIZE:-$effective_cache}
 fi
@@ -131,7 +126,7 @@ function generate_passwd_file() {
   export GROUP_ID=$(id -g)
   grep -v ^postgres /etc/passwd > "$HOME/passwd"
   echo "postgres:x:${USER_ID}:${GROUP_ID}:PostgreSQL Server:${HOME}:/bin/bash" >> "$HOME/passwd"
-  #export LD_PRELOAD=libnss_wrapper.so
+  export LD_PRELOAD=libnss_wrapper.so
   export NSS_WRAPPER_PASSWD=${HOME}/passwd
   export NSS_WRAPPER_GROUP=/etc/group
 }

tests/config.yaml

@@ -1,66 +1,14 @@
 document: modularity-testing
 version: 1
 name: postgresql
-modulemd-url: https://src.fedoraproject.org/cgit/modules/postgresql.git/tree/postgresql.yaml?h=f26
+modulemd-url: https://src.fedoraproject.org/cgit/modules/postgresql.git/plain/postgresql.yaml
 service:
     port: 5432
-packages:
-    rpms:
-        - postgresql-server
-        # seq
-        - coreutils
-testdependecies:
-    rpms:
-        - postgresql
-        - systemd
 module:
     docker:
-        start: "docker run -it -p 5432:5432 -e POSTGRESQL_USER=mtftest -e POSTGRESQL_PASSWORD=mtftest -e POSTGRESQL_DATABASE=mtftest"
-        labels:
-            description: "PostgreSQL is an advanced Object-Relational database management system (DBMS)."
-            io.k8s.description: "PostgreSQL is an advanced Object-Relational database management system (DBMS)."
-        source: https://github.com/container-images/postgresql.git
-        container: docker.io/modularitycontainers/postgresql
+        start: "docker run -it -e POSTGRESQL_USER=user -e POSTGRESQL_PASSWORD=p -e POSTGRESQL_DATABASE=db -e LC_ALL=C -p 5432:5432"
+        container: postgresql
     rpm:
-        setup: postgresql-setup initdb
-        start: systemctl start postgresql
-        stop: systemctl stop postgresql
-        status: systemctl status postgresql
+        start: run-postgresql
         repos:
-            - https://kojipkgs.fedoraproject.org/compose/latest-Fedora-Modular-26/compose/Server/x86_64/os/
-test:
-    process_running:
-        - |
-            up=0
-            for i in `seq 20`; do
-                echo "Checking for /usr/bin/postgres process... ($i)"
-                if ls /proc/*/exe -alh 2>/dev/null | grep /usr/bin/postgres; then
-                    echo "Found."
-                    up=1
-                    break
-                else
-                    sleep 1
-                fi
-            done
-            test "$up" -ne 0
-testhost:
-    db_usable:
-        - |
-            export PGPASSWORD=mtftest
-            PSQL="psql -h localhost -U mtftest -q"
-            up=0
-            for i in `seq 20`; do
-                echo "Pinging PostgreSQL ($i)"
-                if $PSQL -c "" >&/dev/null; then
-                    up=1
-                    break
-                else
-                    sleep 1
-                fi
-            done
-            if [ "$up" -eq 1 ]; then
-                $PSQL -f test.sql | egrep "anything|something"
-            else
-                echo "Unable to connect to database." >&2
-                false
-            fi
+            - http://mirror.vutbr.cz/fedora/releases/26/Everything/x86_64/os/

tests/rpmvalidator.py

@@ -0,0 +1,56 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+#
+# This Modularity Testing Framework helps you to write tests for modules
+# Copyright (C) 2017 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# he Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Authors: Jan Scotka <jscotka@redhat.com>
+#
+
+from avocado import main
+from moduleframework import module_framework
+
+
+class ExampleRpmValidation(module_framework.AvocadoTest):
+    """
+    :avocado: enable
+    """
+    fhs_base_paths = [
+        '/bin',
+        '/boot',
+        '/dev',
+        '/etc',
+        '/home',
+        '/lib',
+        '/lib64',
+        '/media',
+        '/mnt',
+        '/opt',
+        '/proc',
+        '/root',
+        '/run',
+        '/sbin',
+        '/sys',
+        '/srv',
+        '/tmp',
+        '/usr/bin'
+    ]
+
+    def testPaths(self):
+        self.start()
+        for directory in self.fhs_base_paths:
+            self.run("test -d %s" % directory)

tests/sanity1.py

@@ -0,0 +1,46 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+#
+# This Modularity Testing Framework helps you to write tests for modules
+# Copyright (C) 2017 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# he Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Authors: Rado Pitonak <rpitonak@redhat.com>
+#
+
+from avocado import main
+from avocado.core import exceptions
+from moduleframework import module_framework
+
+
+class SanityCheck1(module_framework.AvocadoTest):
+    """
+    :avocado: enable
+    """
+
+    def test1(self):
+        self.start()
+        self.run("ls / | grep bin")
+
+    # check if perl is installed in the right version.
+    def test2PostgresVersion(self):
+        postgresVersion = "9.6"
+        self.start()
+        self.run("postgres --version | grep " + postgresVersion)
+
+
+if __name__ == '__main__':
+    main()

tests/sanity2.py

@@ -0,0 +1,47 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+#
+# This Modularity Testing Framework helps you to write tests for modules
+# Copyright (C) 2017 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# he Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Authors: Rado Pitonak <rpitonak@redhat.com>
+#
+
+from avocado import main
+from avocado.core import exceptions
+from moduleframework import module_framework
+import time
+
+
+class SanityCheck2(module_framework.AvocadoTest):
+    """
+    :avocado: enable
+    """
+
+    def testConnectToDB(self):
+        self.start()
+        time.sleep(5)
+        self.run("psql -U $POSTGRESQL_USER -d $POSTGRESQL_DATABASE -c 'SELECT 1'")
+
+    def testCreateTable(self):
+        self.start()
+        time.sleep(5)
+        self.run("psql -U $POSTGRESQL_USER -d $POSTGRESQL_DATABASE -c 'CREATE TABLE mytable(ID INT PRIMARY KEY NOT NULL);'")
+
+
+if __name__ == '__main__':
+    main()

tests/simpleTest.py

@@ -0,0 +1,47 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+#
+# This Modularity Testing Framework helps you to write tests for modules
+# Copyright (C) 2017 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# he Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Authors: Jan Scotka <jscotka@redhat.com>
+#
+
+from moduleframework import module_framework
+import os
+
+
+class simpleTests(module_framework.AvocadoTest):
+    """
+    :avocado: enable
+    """
+
+    def testPath(self):
+        print ">>>>>>>>>>>>>> ", module_framework.__file__
+        print ">>>>>>>>>>>>>> ", __file__
+
+    def testAssertIn(self):
+        self.start()
+        self.assertIn("sbin", self.run("ls /").stdout)
+
+    def testInsideModule(self):
+        self.start()
+        self.assertEqual("a", self.run("echo a").stdout.strip())
+
+    def testCommandOnHost(self):
+        self.start()
+        self.assertEqual("a", self.runHost("echo a").stdout.strip())

tests/test.sql

@@ -1,5 +0,0 @@
-CREATE TABLE mtftest (id SERIAL NOT NULL, anything VARCHAR(255) NOT NULL);
-
-INSERT INTO mtftest (anything) VALUES ('something');
-
-SELECT anything FROM mtftest;