From d5c1a02e7abdfdc0de7f50df7a0b8222275c52cf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Roland=20Hu=C3=9F?= Date: Wed, 29 Apr 2020 17:27:06 +0200 Subject: [PATCH] Update dependencies and java versions --- fish-pepper.yml | 2 +- images.yml | 22 +++++++++++----------- images/alpine/openjdk11/jdk/Dockerfile | 4 ++-- images/alpine/openjdk11/jdk/README.md | 2 +- images/alpine/openjdk11/jdk/run-java.sh | 11 ++++++++--- images/alpine/openjdk11/jre/Dockerfile | 4 ++-- images/alpine/openjdk11/jre/README.md | 2 +- images/alpine/openjdk11/jre/run-java.sh | 11 ++++++++--- images/alpine/openjdk7/jdk/Dockerfile | 2 +- images/alpine/openjdk7/jdk/README.md | 2 +- images/alpine/openjdk7/jdk/run-java.sh | 11 ++++++++--- images/alpine/openjdk7/jre/Dockerfile | 2 +- images/alpine/openjdk7/jre/README.md | 2 +- images/alpine/openjdk7/jre/run-java.sh | 11 ++++++++--- images/alpine/openjdk8/jdk/Dockerfile | 4 ++-- images/alpine/openjdk8/jdk/README.md | 2 +- images/alpine/openjdk8/jdk/run-java.sh | 11 ++++++++--- images/alpine/openjdk8/jre/Dockerfile | 4 ++-- images/alpine/openjdk8/jre/README.md | 2 +- images/alpine/openjdk8/jre/run-java.sh | 11 ++++++++--- images/centos/openjdk11/jdk/Dockerfile | 4 ++-- images/centos/openjdk11/jdk/run-java.sh | 11 ++++++++--- images/centos/openjdk11/jre/Dockerfile | 2 +- images/centos/openjdk11/jre/run-java.sh | 11 ++++++++--- images/centos/openjdk7/jdk/Dockerfile | 4 ++-- images/centos/openjdk7/jdk/run-java.sh | 11 ++++++++--- images/centos/openjdk7/jre/Dockerfile | 2 +- images/centos/openjdk7/jre/run-java.sh | 11 ++++++++--- images/centos/openjdk8/jdk/Dockerfile | 4 ++-- images/centos/openjdk8/jdk/run-java.sh | 11 ++++++++--- images/centos/openjdk8/jre/Dockerfile | 2 +- images/centos/openjdk8/jre/run-java.sh | 11 ++++++++--- images/jboss/openjdk7/jdk/run-java.sh | 11 ++++++++--- images/jboss/openjdk8/jdk/run-java.sh | 11 ++++++++--- images/ubi/openjdk11/jdk/Dockerfile | 4 ++-- images/ubi/openjdk11/jdk/run-java.sh | 11 ++++++++--- images/ubi/openjdk8/jdk/Dockerfile | 4 ++-- images/ubi/openjdk8/jdk/run-java.sh | 11 ++++++++--- 38 files changed, 169 insertions(+), 89 deletions(-) diff --git a/fish-pepper.yml b/fish-pepper.yml index aefeb05..9e41a23 100644 --- a/fish-pepper.yml +++ b/fish-pepper.yml @@ -19,7 +19,7 @@ blocks: # run-java.sh for starting up Java processes - type: "git" url: "https://github.com/fabric8io-images/run-java-sh.git" - tag: v1.3.6 + tag: v1.3.7 # agent bond for export Jolokia and jmx_exporter data - type: "git" url: "https://github.com/fabric8io/agent-bond.git" diff --git a/images.yml b/images.yml index a285569..79a9fe5 100644 --- a/images.yml +++ b/images.yml @@ -5,7 +5,7 @@ fish-pepper: - version - type name: "fabric8/java" - build: "1.7.0" + build: "1.8.0" # Used for escaping in 'agent-bond-opts' where the same delimiters are used abSepOpen: "{{" @@ -17,13 +17,13 @@ config: agent: "agent-bond" baseDir: "/deployments" alpine: - from: "alpine:3.10" - version: "3.10" + from: "alpine:3.11" + version: "3.11" description: "Alpine" javaPackage: 7: 7.221.2.6.18-r0 - 8: 8.222.10-r0 - 11: 11.0.4_p4-r1 + 8: 8.242.08-r0 + 11: 11.0.5_p10-r0 centos: from: "centos:7.7.1908" createUser: true @@ -31,19 +31,19 @@ config: version: "7" description: "CentOS" javaPackage: - 7: 1.7.0.251-2.6.21.0.el7_7 - 8: 1.8.0.242.b08-0.el7_7 - 11: 11.0.6.10-1.el7_7 + 7: 1.7.0.251-2.6.21.1.el7 + 8: 1.8.0.242.b08-1.el7 + 11: 11.0.6.10-3.el7 ubi: - from: "registry.access.redhat.com/ubi8/ubi-minimal:8.1-398" + from: "registry.access.redhat.com/ubi8/ubi-minimal:8.2-267" createUser: false createUBIUser: true ubiUser: 1001 version: "8.1" description: "UBI" javaPackage: - 8: 1.8.0.242.b08-0.el8_1 - 11: 11.0.6.10-0.el8_1 + 8: 1.8.0.252.b09-2.el8_1 + 11: 11.0.7.10-1.el8_1 jboss: deprecated: true from: "jboss/base-jdk" diff --git a/images/alpine/openjdk11/jdk/Dockerfile b/images/alpine/openjdk11/jdk/Dockerfile index 1270dd1..9529e2d 100644 --- a/images/alpine/openjdk11/jdk/Dockerfile +++ b/images/alpine/openjdk11/jdk/Dockerfile @@ -1,4 +1,4 @@ -FROM alpine:3.10 +FROM alpine:3.11 USER root @@ -13,7 +13,7 @@ ENV JAVA_APP_DIR=/deployments \ # according to http://www.2uo.de/myths-about-urandom/ RUN apk add --update \ curl \ - openjdk11=11.0.4_p4-r1 \ + openjdk11=11.0.5_p10-r0 \ && rm /var/cache/apk/* \ && echo "securerandom.source=file:/dev/urandom" >> /usr/lib/jvm/default-jvm/jre/lib/security/java.security diff --git a/images/alpine/openjdk11/jdk/README.md b/images/alpine/openjdk11/jdk/README.md index c3d0c73..d084696 100644 --- a/images/alpine/openjdk11/jdk/README.md +++ b/images/alpine/openjdk11/jdk/README.md @@ -179,6 +179,6 @@ mvn clean install ### Versions: -* Base-Image: **Alpine 3.10** +* Base-Image: **Alpine 3.11** * Java: **OpenJDK 11 11** (Java Development Kit (JDK)) * Agent-Bond: **1.2.0** (Jolokia 1.6.2, jmx_exporter 0.3.1) diff --git a/images/alpine/openjdk11/jdk/run-java.sh b/images/alpine/openjdk11/jdk/run-java.sh index 83a369a..e5e2731 100644 --- a/images/alpine/openjdk11/jdk/run-java.sh +++ b/images/alpine/openjdk11/jdk/run-java.sh @@ -33,7 +33,7 @@ # https://www.youtube.com/watch?v=w1rZOY5gbvk # https://vimeo.com/album/4133413/video/181900266 # Also note that heap is only a small portion of the memory used by a JVM. There are lot -# of other memory areas (metadata, thread, code cache, ...) which addes to the overall +# of other memory areas (metadata, thread, code cache, ...) which adds to the overall # size. When your container gets killed because of an OOM, then you should tune # the absolute values. # JAVA_INIT_MEM_RATIO: Ratio use to calculate a default intial heap memory, in percent. @@ -254,14 +254,19 @@ run_java_options() { debug_options() { if [ -n "${JAVA_ENABLE_DEBUG:-}" ] || [ -n "${JAVA_DEBUG_ENABLE:-}" ] || [ -n "${JAVA_DEBUG:-}" ]; then - local debug_port="${JAVA_DEBUG_PORT:-5005}" + local debug_port="${JAVA_DEBUG_PORT:-5005}" local suspend_mode="n" if [ -n "${JAVA_DEBUG_SUSPEND:-}" ]; then if ! echo "${JAVA_DEBUG_SUSPEND}" | grep -q -e '^\(false\|n\|no\|0\)$'; then suspend_mode="y" fi fi - echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${debug_port}" + + local address_prefix="" + if [ "${JAVA_MAJOR_VERSION:-0}" -ge "9" ]; then + address_prefix="*:" + fi + echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${address_prefix}${debug_port}" fi } diff --git a/images/alpine/openjdk11/jre/Dockerfile b/images/alpine/openjdk11/jre/Dockerfile index 5a5d1c1..bab80fc 100644 --- a/images/alpine/openjdk11/jre/Dockerfile +++ b/images/alpine/openjdk11/jre/Dockerfile @@ -1,4 +1,4 @@ -FROM alpine:3.10 +FROM alpine:3.11 USER root @@ -13,7 +13,7 @@ ENV JAVA_APP_DIR=/deployments \ # according to http://www.2uo.de/myths-about-urandom/ RUN apk add --update \ curl \ - openjdk11-jre=11.0.4_p4-r1 \ + openjdk11-jre=11.0.5_p10-r0 \ && rm /var/cache/apk/* \ && echo "securerandom.source=file:/dev/urandom" >> /usr/lib/jvm/default-jvm/jre/lib/security/java.security diff --git a/images/alpine/openjdk11/jre/README.md b/images/alpine/openjdk11/jre/README.md index f4c2f50..e28c7b1 100644 --- a/images/alpine/openjdk11/jre/README.md +++ b/images/alpine/openjdk11/jre/README.md @@ -179,6 +179,6 @@ mvn clean install ### Versions: -* Base-Image: **Alpine 3.10** +* Base-Image: **Alpine 3.11** * Java: **OpenJDK 11 11** (Java Runtime Environment (JRE)) * Agent-Bond: **1.2.0** (Jolokia 1.6.2, jmx_exporter 0.3.1) diff --git a/images/alpine/openjdk11/jre/run-java.sh b/images/alpine/openjdk11/jre/run-java.sh index 83a369a..e5e2731 100644 --- a/images/alpine/openjdk11/jre/run-java.sh +++ b/images/alpine/openjdk11/jre/run-java.sh @@ -33,7 +33,7 @@ # https://www.youtube.com/watch?v=w1rZOY5gbvk # https://vimeo.com/album/4133413/video/181900266 # Also note that heap is only a small portion of the memory used by a JVM. There are lot -# of other memory areas (metadata, thread, code cache, ...) which addes to the overall +# of other memory areas (metadata, thread, code cache, ...) which adds to the overall # size. When your container gets killed because of an OOM, then you should tune # the absolute values. # JAVA_INIT_MEM_RATIO: Ratio use to calculate a default intial heap memory, in percent. @@ -254,14 +254,19 @@ run_java_options() { debug_options() { if [ -n "${JAVA_ENABLE_DEBUG:-}" ] || [ -n "${JAVA_DEBUG_ENABLE:-}" ] || [ -n "${JAVA_DEBUG:-}" ]; then - local debug_port="${JAVA_DEBUG_PORT:-5005}" + local debug_port="${JAVA_DEBUG_PORT:-5005}" local suspend_mode="n" if [ -n "${JAVA_DEBUG_SUSPEND:-}" ]; then if ! echo "${JAVA_DEBUG_SUSPEND}" | grep -q -e '^\(false\|n\|no\|0\)$'; then suspend_mode="y" fi fi - echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${debug_port}" + + local address_prefix="" + if [ "${JAVA_MAJOR_VERSION:-0}" -ge "9" ]; then + address_prefix="*:" + fi + echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${address_prefix}${debug_port}" fi } diff --git a/images/alpine/openjdk7/jdk/Dockerfile b/images/alpine/openjdk7/jdk/Dockerfile index dfc6213..dd0448d 100644 --- a/images/alpine/openjdk7/jdk/Dockerfile +++ b/images/alpine/openjdk7/jdk/Dockerfile @@ -1,4 +1,4 @@ -FROM alpine:3.10 +FROM alpine:3.11 USER root diff --git a/images/alpine/openjdk7/jdk/README.md b/images/alpine/openjdk7/jdk/README.md index b05a5e6..9b57f2b 100644 --- a/images/alpine/openjdk7/jdk/README.md +++ b/images/alpine/openjdk7/jdk/README.md @@ -179,6 +179,6 @@ mvn clean install ### Versions: -* Base-Image: **Alpine 3.10** +* Base-Image: **Alpine 3.11** * Java: **OpenJDK 7 1.7.0** (Java Development Kit (JDK)) * Agent-Bond: **1.2.0** (Jolokia 1.6.2, jmx_exporter 0.3.1) diff --git a/images/alpine/openjdk7/jdk/run-java.sh b/images/alpine/openjdk7/jdk/run-java.sh index 83a369a..e5e2731 100644 --- a/images/alpine/openjdk7/jdk/run-java.sh +++ b/images/alpine/openjdk7/jdk/run-java.sh @@ -33,7 +33,7 @@ # https://www.youtube.com/watch?v=w1rZOY5gbvk # https://vimeo.com/album/4133413/video/181900266 # Also note that heap is only a small portion of the memory used by a JVM. There are lot -# of other memory areas (metadata, thread, code cache, ...) which addes to the overall +# of other memory areas (metadata, thread, code cache, ...) which adds to the overall # size. When your container gets killed because of an OOM, then you should tune # the absolute values. # JAVA_INIT_MEM_RATIO: Ratio use to calculate a default intial heap memory, in percent. @@ -254,14 +254,19 @@ run_java_options() { debug_options() { if [ -n "${JAVA_ENABLE_DEBUG:-}" ] || [ -n "${JAVA_DEBUG_ENABLE:-}" ] || [ -n "${JAVA_DEBUG:-}" ]; then - local debug_port="${JAVA_DEBUG_PORT:-5005}" + local debug_port="${JAVA_DEBUG_PORT:-5005}" local suspend_mode="n" if [ -n "${JAVA_DEBUG_SUSPEND:-}" ]; then if ! echo "${JAVA_DEBUG_SUSPEND}" | grep -q -e '^\(false\|n\|no\|0\)$'; then suspend_mode="y" fi fi - echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${debug_port}" + + local address_prefix="" + if [ "${JAVA_MAJOR_VERSION:-0}" -ge "9" ]; then + address_prefix="*:" + fi + echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${address_prefix}${debug_port}" fi } diff --git a/images/alpine/openjdk7/jre/Dockerfile b/images/alpine/openjdk7/jre/Dockerfile index 50f4c9b..c279d45 100644 --- a/images/alpine/openjdk7/jre/Dockerfile +++ b/images/alpine/openjdk7/jre/Dockerfile @@ -1,4 +1,4 @@ -FROM alpine:3.10 +FROM alpine:3.11 USER root diff --git a/images/alpine/openjdk7/jre/README.md b/images/alpine/openjdk7/jre/README.md index 4725965..549cbe4 100644 --- a/images/alpine/openjdk7/jre/README.md +++ b/images/alpine/openjdk7/jre/README.md @@ -179,6 +179,6 @@ mvn clean install ### Versions: -* Base-Image: **Alpine 3.10** +* Base-Image: **Alpine 3.11** * Java: **OpenJDK 7 1.7.0** (Java Runtime Environment (JRE)) * Agent-Bond: **1.2.0** (Jolokia 1.6.2, jmx_exporter 0.3.1) diff --git a/images/alpine/openjdk7/jre/run-java.sh b/images/alpine/openjdk7/jre/run-java.sh index 83a369a..e5e2731 100644 --- a/images/alpine/openjdk7/jre/run-java.sh +++ b/images/alpine/openjdk7/jre/run-java.sh @@ -33,7 +33,7 @@ # https://www.youtube.com/watch?v=w1rZOY5gbvk # https://vimeo.com/album/4133413/video/181900266 # Also note that heap is only a small portion of the memory used by a JVM. There are lot -# of other memory areas (metadata, thread, code cache, ...) which addes to the overall +# of other memory areas (metadata, thread, code cache, ...) which adds to the overall # size. When your container gets killed because of an OOM, then you should tune # the absolute values. # JAVA_INIT_MEM_RATIO: Ratio use to calculate a default intial heap memory, in percent. @@ -254,14 +254,19 @@ run_java_options() { debug_options() { if [ -n "${JAVA_ENABLE_DEBUG:-}" ] || [ -n "${JAVA_DEBUG_ENABLE:-}" ] || [ -n "${JAVA_DEBUG:-}" ]; then - local debug_port="${JAVA_DEBUG_PORT:-5005}" + local debug_port="${JAVA_DEBUG_PORT:-5005}" local suspend_mode="n" if [ -n "${JAVA_DEBUG_SUSPEND:-}" ]; then if ! echo "${JAVA_DEBUG_SUSPEND}" | grep -q -e '^\(false\|n\|no\|0\)$'; then suspend_mode="y" fi fi - echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${debug_port}" + + local address_prefix="" + if [ "${JAVA_MAJOR_VERSION:-0}" -ge "9" ]; then + address_prefix="*:" + fi + echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${address_prefix}${debug_port}" fi } diff --git a/images/alpine/openjdk8/jdk/Dockerfile b/images/alpine/openjdk8/jdk/Dockerfile index dbc2b1d..ce712c5 100644 --- a/images/alpine/openjdk8/jdk/Dockerfile +++ b/images/alpine/openjdk8/jdk/Dockerfile @@ -1,4 +1,4 @@ -FROM alpine:3.10 +FROM alpine:3.11 USER root @@ -13,7 +13,7 @@ ENV JAVA_APP_DIR=/deployments \ # according to http://www.2uo.de/myths-about-urandom/ RUN apk add --update \ curl \ - openjdk8=8.222.10-r0 \ + openjdk8=8.242.08-r0 \ && rm /var/cache/apk/* \ && echo "securerandom.source=file:/dev/urandom" >> /usr/lib/jvm/default-jvm/jre/lib/security/java.security diff --git a/images/alpine/openjdk8/jdk/README.md b/images/alpine/openjdk8/jdk/README.md index da5947b..0f0b09a 100644 --- a/images/alpine/openjdk8/jdk/README.md +++ b/images/alpine/openjdk8/jdk/README.md @@ -179,6 +179,6 @@ mvn clean install ### Versions: -* Base-Image: **Alpine 3.10** +* Base-Image: **Alpine 3.11** * Java: **OpenJDK 8 1.8.0** (Java Development Kit (JDK)) * Agent-Bond: **1.2.0** (Jolokia 1.6.2, jmx_exporter 0.3.1) diff --git a/images/alpine/openjdk8/jdk/run-java.sh b/images/alpine/openjdk8/jdk/run-java.sh index 83a369a..e5e2731 100644 --- a/images/alpine/openjdk8/jdk/run-java.sh +++ b/images/alpine/openjdk8/jdk/run-java.sh @@ -33,7 +33,7 @@ # https://www.youtube.com/watch?v=w1rZOY5gbvk # https://vimeo.com/album/4133413/video/181900266 # Also note that heap is only a small portion of the memory used by a JVM. There are lot -# of other memory areas (metadata, thread, code cache, ...) which addes to the overall +# of other memory areas (metadata, thread, code cache, ...) which adds to the overall # size. When your container gets killed because of an OOM, then you should tune # the absolute values. # JAVA_INIT_MEM_RATIO: Ratio use to calculate a default intial heap memory, in percent. @@ -254,14 +254,19 @@ run_java_options() { debug_options() { if [ -n "${JAVA_ENABLE_DEBUG:-}" ] || [ -n "${JAVA_DEBUG_ENABLE:-}" ] || [ -n "${JAVA_DEBUG:-}" ]; then - local debug_port="${JAVA_DEBUG_PORT:-5005}" + local debug_port="${JAVA_DEBUG_PORT:-5005}" local suspend_mode="n" if [ -n "${JAVA_DEBUG_SUSPEND:-}" ]; then if ! echo "${JAVA_DEBUG_SUSPEND}" | grep -q -e '^\(false\|n\|no\|0\)$'; then suspend_mode="y" fi fi - echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${debug_port}" + + local address_prefix="" + if [ "${JAVA_MAJOR_VERSION:-0}" -ge "9" ]; then + address_prefix="*:" + fi + echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${address_prefix}${debug_port}" fi } diff --git a/images/alpine/openjdk8/jre/Dockerfile b/images/alpine/openjdk8/jre/Dockerfile index a5a85e7..ac46b4d 100644 --- a/images/alpine/openjdk8/jre/Dockerfile +++ b/images/alpine/openjdk8/jre/Dockerfile @@ -1,4 +1,4 @@ -FROM alpine:3.10 +FROM alpine:3.11 USER root @@ -13,7 +13,7 @@ ENV JAVA_APP_DIR=/deployments \ # according to http://www.2uo.de/myths-about-urandom/ RUN apk add --update \ curl \ - openjdk8-jre=8.222.10-r0 \ + openjdk8-jre=8.242.08-r0 \ && rm /var/cache/apk/* \ && echo "securerandom.source=file:/dev/urandom" >> /usr/lib/jvm/default-jvm/jre/lib/security/java.security diff --git a/images/alpine/openjdk8/jre/README.md b/images/alpine/openjdk8/jre/README.md index 2cb13dd..ff7bb3b 100644 --- a/images/alpine/openjdk8/jre/README.md +++ b/images/alpine/openjdk8/jre/README.md @@ -179,6 +179,6 @@ mvn clean install ### Versions: -* Base-Image: **Alpine 3.10** +* Base-Image: **Alpine 3.11** * Java: **OpenJDK 8 1.8.0** (Java Runtime Environment (JRE)) * Agent-Bond: **1.2.0** (Jolokia 1.6.2, jmx_exporter 0.3.1) diff --git a/images/alpine/openjdk8/jre/run-java.sh b/images/alpine/openjdk8/jre/run-java.sh index 83a369a..e5e2731 100644 --- a/images/alpine/openjdk8/jre/run-java.sh +++ b/images/alpine/openjdk8/jre/run-java.sh @@ -33,7 +33,7 @@ # https://www.youtube.com/watch?v=w1rZOY5gbvk # https://vimeo.com/album/4133413/video/181900266 # Also note that heap is only a small portion of the memory used by a JVM. There are lot -# of other memory areas (metadata, thread, code cache, ...) which addes to the overall +# of other memory areas (metadata, thread, code cache, ...) which adds to the overall # size. When your container gets killed because of an OOM, then you should tune # the absolute values. # JAVA_INIT_MEM_RATIO: Ratio use to calculate a default intial heap memory, in percent. @@ -254,14 +254,19 @@ run_java_options() { debug_options() { if [ -n "${JAVA_ENABLE_DEBUG:-}" ] || [ -n "${JAVA_DEBUG_ENABLE:-}" ] || [ -n "${JAVA_DEBUG:-}" ]; then - local debug_port="${JAVA_DEBUG_PORT:-5005}" + local debug_port="${JAVA_DEBUG_PORT:-5005}" local suspend_mode="n" if [ -n "${JAVA_DEBUG_SUSPEND:-}" ]; then if ! echo "${JAVA_DEBUG_SUSPEND}" | grep -q -e '^\(false\|n\|no\|0\)$'; then suspend_mode="y" fi fi - echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${debug_port}" + + local address_prefix="" + if [ "${JAVA_MAJOR_VERSION:-0}" -ge "9" ]; then + address_prefix="*:" + fi + echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${address_prefix}${debug_port}" fi } diff --git a/images/centos/openjdk11/jdk/Dockerfile b/images/centos/openjdk11/jdk/Dockerfile index 286deac..77ca046 100644 --- a/images/centos/openjdk11/jdk/Dockerfile +++ b/images/centos/openjdk11/jdk/Dockerfile @@ -12,8 +12,8 @@ ENV JAVA_APP_DIR=/deployments \ # /dev/urandom is used as random source, which is prefectly safe # according to http://www.2uo.de/myths-about-urandom/ RUN yum install -y \ - java-11-openjdk-11.0.6.10-1.el7_7 \ - java-11-openjdk-devel-11.0.6.10-1.el7_7 \ + java-11-openjdk-11.0.6.10-3.el7 \ + java-11-openjdk-devel-11.0.6.10-3.el7 \ && echo "securerandom.source=file:/dev/urandom" >> /usr/lib/jvm/jre/lib/security/java.security \ && yum clean all diff --git a/images/centos/openjdk11/jdk/run-java.sh b/images/centos/openjdk11/jdk/run-java.sh index 83a369a..e5e2731 100644 --- a/images/centos/openjdk11/jdk/run-java.sh +++ b/images/centos/openjdk11/jdk/run-java.sh @@ -33,7 +33,7 @@ # https://www.youtube.com/watch?v=w1rZOY5gbvk # https://vimeo.com/album/4133413/video/181900266 # Also note that heap is only a small portion of the memory used by a JVM. There are lot -# of other memory areas (metadata, thread, code cache, ...) which addes to the overall +# of other memory areas (metadata, thread, code cache, ...) which adds to the overall # size. When your container gets killed because of an OOM, then you should tune # the absolute values. # JAVA_INIT_MEM_RATIO: Ratio use to calculate a default intial heap memory, in percent. @@ -254,14 +254,19 @@ run_java_options() { debug_options() { if [ -n "${JAVA_ENABLE_DEBUG:-}" ] || [ -n "${JAVA_DEBUG_ENABLE:-}" ] || [ -n "${JAVA_DEBUG:-}" ]; then - local debug_port="${JAVA_DEBUG_PORT:-5005}" + local debug_port="${JAVA_DEBUG_PORT:-5005}" local suspend_mode="n" if [ -n "${JAVA_DEBUG_SUSPEND:-}" ]; then if ! echo "${JAVA_DEBUG_SUSPEND}" | grep -q -e '^\(false\|n\|no\|0\)$'; then suspend_mode="y" fi fi - echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${debug_port}" + + local address_prefix="" + if [ "${JAVA_MAJOR_VERSION:-0}" -ge "9" ]; then + address_prefix="*:" + fi + echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${address_prefix}${debug_port}" fi } diff --git a/images/centos/openjdk11/jre/Dockerfile b/images/centos/openjdk11/jre/Dockerfile index 6a26f75..d004adb 100644 --- a/images/centos/openjdk11/jre/Dockerfile +++ b/images/centos/openjdk11/jre/Dockerfile @@ -12,7 +12,7 @@ ENV JAVA_APP_DIR=/deployments \ # /dev/urandom is used as random source, which is prefectly safe # according to http://www.2uo.de/myths-about-urandom/ RUN yum install -y \ - java-11-openjdk-11.0.6.10-1.el7_7 \ + java-11-openjdk-11.0.6.10-3.el7 \ && echo "securerandom.source=file:/dev/urandom" >> /usr/lib/jvm/jre/lib/security/java.security \ && yum clean all diff --git a/images/centos/openjdk11/jre/run-java.sh b/images/centos/openjdk11/jre/run-java.sh index 83a369a..e5e2731 100644 --- a/images/centos/openjdk11/jre/run-java.sh +++ b/images/centos/openjdk11/jre/run-java.sh @@ -33,7 +33,7 @@ # https://www.youtube.com/watch?v=w1rZOY5gbvk # https://vimeo.com/album/4133413/video/181900266 # Also note that heap is only a small portion of the memory used by a JVM. There are lot -# of other memory areas (metadata, thread, code cache, ...) which addes to the overall +# of other memory areas (metadata, thread, code cache, ...) which adds to the overall # size. When your container gets killed because of an OOM, then you should tune # the absolute values. # JAVA_INIT_MEM_RATIO: Ratio use to calculate a default intial heap memory, in percent. @@ -254,14 +254,19 @@ run_java_options() { debug_options() { if [ -n "${JAVA_ENABLE_DEBUG:-}" ] || [ -n "${JAVA_DEBUG_ENABLE:-}" ] || [ -n "${JAVA_DEBUG:-}" ]; then - local debug_port="${JAVA_DEBUG_PORT:-5005}" + local debug_port="${JAVA_DEBUG_PORT:-5005}" local suspend_mode="n" if [ -n "${JAVA_DEBUG_SUSPEND:-}" ]; then if ! echo "${JAVA_DEBUG_SUSPEND}" | grep -q -e '^\(false\|n\|no\|0\)$'; then suspend_mode="y" fi fi - echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${debug_port}" + + local address_prefix="" + if [ "${JAVA_MAJOR_VERSION:-0}" -ge "9" ]; then + address_prefix="*:" + fi + echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${address_prefix}${debug_port}" fi } diff --git a/images/centos/openjdk7/jdk/Dockerfile b/images/centos/openjdk7/jdk/Dockerfile index 8b517df..79a9c5c 100644 --- a/images/centos/openjdk7/jdk/Dockerfile +++ b/images/centos/openjdk7/jdk/Dockerfile @@ -12,8 +12,8 @@ ENV JAVA_APP_DIR=/deployments \ # /dev/urandom is used as random source, which is prefectly safe # according to http://www.2uo.de/myths-about-urandom/ RUN yum install -y \ - java-1.7.0-openjdk-1.7.0.251-2.6.21.0.el7_7 \ - java-1.7.0-openjdk-devel-1.7.0.251-2.6.21.0.el7_7 \ + java-1.7.0-openjdk-1.7.0.251-2.6.21.1.el7 \ + java-1.7.0-openjdk-devel-1.7.0.251-2.6.21.1.el7 \ && echo "securerandom.source=file:/dev/urandom" >> /usr/lib/jvm/jre/lib/security/java.security \ && yum clean all diff --git a/images/centos/openjdk7/jdk/run-java.sh b/images/centos/openjdk7/jdk/run-java.sh index 83a369a..e5e2731 100644 --- a/images/centos/openjdk7/jdk/run-java.sh +++ b/images/centos/openjdk7/jdk/run-java.sh @@ -33,7 +33,7 @@ # https://www.youtube.com/watch?v=w1rZOY5gbvk # https://vimeo.com/album/4133413/video/181900266 # Also note that heap is only a small portion of the memory used by a JVM. There are lot -# of other memory areas (metadata, thread, code cache, ...) which addes to the overall +# of other memory areas (metadata, thread, code cache, ...) which adds to the overall # size. When your container gets killed because of an OOM, then you should tune # the absolute values. # JAVA_INIT_MEM_RATIO: Ratio use to calculate a default intial heap memory, in percent. @@ -254,14 +254,19 @@ run_java_options() { debug_options() { if [ -n "${JAVA_ENABLE_DEBUG:-}" ] || [ -n "${JAVA_DEBUG_ENABLE:-}" ] || [ -n "${JAVA_DEBUG:-}" ]; then - local debug_port="${JAVA_DEBUG_PORT:-5005}" + local debug_port="${JAVA_DEBUG_PORT:-5005}" local suspend_mode="n" if [ -n "${JAVA_DEBUG_SUSPEND:-}" ]; then if ! echo "${JAVA_DEBUG_SUSPEND}" | grep -q -e '^\(false\|n\|no\|0\)$'; then suspend_mode="y" fi fi - echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${debug_port}" + + local address_prefix="" + if [ "${JAVA_MAJOR_VERSION:-0}" -ge "9" ]; then + address_prefix="*:" + fi + echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${address_prefix}${debug_port}" fi } diff --git a/images/centos/openjdk7/jre/Dockerfile b/images/centos/openjdk7/jre/Dockerfile index dfa8f0e..55873ce 100644 --- a/images/centos/openjdk7/jre/Dockerfile +++ b/images/centos/openjdk7/jre/Dockerfile @@ -12,7 +12,7 @@ ENV JAVA_APP_DIR=/deployments \ # /dev/urandom is used as random source, which is prefectly safe # according to http://www.2uo.de/myths-about-urandom/ RUN yum install -y \ - java-1.7.0-openjdk-1.7.0.251-2.6.21.0.el7_7 \ + java-1.7.0-openjdk-1.7.0.251-2.6.21.1.el7 \ && echo "securerandom.source=file:/dev/urandom" >> /usr/lib/jvm/jre/lib/security/java.security \ && yum clean all diff --git a/images/centos/openjdk7/jre/run-java.sh b/images/centos/openjdk7/jre/run-java.sh index 83a369a..e5e2731 100644 --- a/images/centos/openjdk7/jre/run-java.sh +++ b/images/centos/openjdk7/jre/run-java.sh @@ -33,7 +33,7 @@ # https://www.youtube.com/watch?v=w1rZOY5gbvk # https://vimeo.com/album/4133413/video/181900266 # Also note that heap is only a small portion of the memory used by a JVM. There are lot -# of other memory areas (metadata, thread, code cache, ...) which addes to the overall +# of other memory areas (metadata, thread, code cache, ...) which adds to the overall # size. When your container gets killed because of an OOM, then you should tune # the absolute values. # JAVA_INIT_MEM_RATIO: Ratio use to calculate a default intial heap memory, in percent. @@ -254,14 +254,19 @@ run_java_options() { debug_options() { if [ -n "${JAVA_ENABLE_DEBUG:-}" ] || [ -n "${JAVA_DEBUG_ENABLE:-}" ] || [ -n "${JAVA_DEBUG:-}" ]; then - local debug_port="${JAVA_DEBUG_PORT:-5005}" + local debug_port="${JAVA_DEBUG_PORT:-5005}" local suspend_mode="n" if [ -n "${JAVA_DEBUG_SUSPEND:-}" ]; then if ! echo "${JAVA_DEBUG_SUSPEND}" | grep -q -e '^\(false\|n\|no\|0\)$'; then suspend_mode="y" fi fi - echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${debug_port}" + + local address_prefix="" + if [ "${JAVA_MAJOR_VERSION:-0}" -ge "9" ]; then + address_prefix="*:" + fi + echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${address_prefix}${debug_port}" fi } diff --git a/images/centos/openjdk8/jdk/Dockerfile b/images/centos/openjdk8/jdk/Dockerfile index bb6f5d3..570f974 100644 --- a/images/centos/openjdk8/jdk/Dockerfile +++ b/images/centos/openjdk8/jdk/Dockerfile @@ -12,8 +12,8 @@ ENV JAVA_APP_DIR=/deployments \ # /dev/urandom is used as random source, which is prefectly safe # according to http://www.2uo.de/myths-about-urandom/ RUN yum install -y \ - java-1.8.0-openjdk-1.8.0.242.b08-0.el7_7 \ - java-1.8.0-openjdk-devel-1.8.0.242.b08-0.el7_7 \ + java-1.8.0-openjdk-1.8.0.242.b08-1.el7 \ + java-1.8.0-openjdk-devel-1.8.0.242.b08-1.el7 \ && echo "securerandom.source=file:/dev/urandom" >> /usr/lib/jvm/jre/lib/security/java.security \ && yum clean all diff --git a/images/centos/openjdk8/jdk/run-java.sh b/images/centos/openjdk8/jdk/run-java.sh index 83a369a..e5e2731 100644 --- a/images/centos/openjdk8/jdk/run-java.sh +++ b/images/centos/openjdk8/jdk/run-java.sh @@ -33,7 +33,7 @@ # https://www.youtube.com/watch?v=w1rZOY5gbvk # https://vimeo.com/album/4133413/video/181900266 # Also note that heap is only a small portion of the memory used by a JVM. There are lot -# of other memory areas (metadata, thread, code cache, ...) which addes to the overall +# of other memory areas (metadata, thread, code cache, ...) which adds to the overall # size. When your container gets killed because of an OOM, then you should tune # the absolute values. # JAVA_INIT_MEM_RATIO: Ratio use to calculate a default intial heap memory, in percent. @@ -254,14 +254,19 @@ run_java_options() { debug_options() { if [ -n "${JAVA_ENABLE_DEBUG:-}" ] || [ -n "${JAVA_DEBUG_ENABLE:-}" ] || [ -n "${JAVA_DEBUG:-}" ]; then - local debug_port="${JAVA_DEBUG_PORT:-5005}" + local debug_port="${JAVA_DEBUG_PORT:-5005}" local suspend_mode="n" if [ -n "${JAVA_DEBUG_SUSPEND:-}" ]; then if ! echo "${JAVA_DEBUG_SUSPEND}" | grep -q -e '^\(false\|n\|no\|0\)$'; then suspend_mode="y" fi fi - echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${debug_port}" + + local address_prefix="" + if [ "${JAVA_MAJOR_VERSION:-0}" -ge "9" ]; then + address_prefix="*:" + fi + echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${address_prefix}${debug_port}" fi } diff --git a/images/centos/openjdk8/jre/Dockerfile b/images/centos/openjdk8/jre/Dockerfile index 323d459..d143064 100644 --- a/images/centos/openjdk8/jre/Dockerfile +++ b/images/centos/openjdk8/jre/Dockerfile @@ -12,7 +12,7 @@ ENV JAVA_APP_DIR=/deployments \ # /dev/urandom is used as random source, which is prefectly safe # according to http://www.2uo.de/myths-about-urandom/ RUN yum install -y \ - java-1.8.0-openjdk-1.8.0.242.b08-0.el7_7 \ + java-1.8.0-openjdk-1.8.0.242.b08-1.el7 \ && echo "securerandom.source=file:/dev/urandom" >> /usr/lib/jvm/jre/lib/security/java.security \ && yum clean all diff --git a/images/centos/openjdk8/jre/run-java.sh b/images/centos/openjdk8/jre/run-java.sh index 83a369a..e5e2731 100644 --- a/images/centos/openjdk8/jre/run-java.sh +++ b/images/centos/openjdk8/jre/run-java.sh @@ -33,7 +33,7 @@ # https://www.youtube.com/watch?v=w1rZOY5gbvk # https://vimeo.com/album/4133413/video/181900266 # Also note that heap is only a small portion of the memory used by a JVM. There are lot -# of other memory areas (metadata, thread, code cache, ...) which addes to the overall +# of other memory areas (metadata, thread, code cache, ...) which adds to the overall # size. When your container gets killed because of an OOM, then you should tune # the absolute values. # JAVA_INIT_MEM_RATIO: Ratio use to calculate a default intial heap memory, in percent. @@ -254,14 +254,19 @@ run_java_options() { debug_options() { if [ -n "${JAVA_ENABLE_DEBUG:-}" ] || [ -n "${JAVA_DEBUG_ENABLE:-}" ] || [ -n "${JAVA_DEBUG:-}" ]; then - local debug_port="${JAVA_DEBUG_PORT:-5005}" + local debug_port="${JAVA_DEBUG_PORT:-5005}" local suspend_mode="n" if [ -n "${JAVA_DEBUG_SUSPEND:-}" ]; then if ! echo "${JAVA_DEBUG_SUSPEND}" | grep -q -e '^\(false\|n\|no\|0\)$'; then suspend_mode="y" fi fi - echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${debug_port}" + + local address_prefix="" + if [ "${JAVA_MAJOR_VERSION:-0}" -ge "9" ]; then + address_prefix="*:" + fi + echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${address_prefix}${debug_port}" fi } diff --git a/images/jboss/openjdk7/jdk/run-java.sh b/images/jboss/openjdk7/jdk/run-java.sh index 83a369a..e5e2731 100644 --- a/images/jboss/openjdk7/jdk/run-java.sh +++ b/images/jboss/openjdk7/jdk/run-java.sh @@ -33,7 +33,7 @@ # https://www.youtube.com/watch?v=w1rZOY5gbvk # https://vimeo.com/album/4133413/video/181900266 # Also note that heap is only a small portion of the memory used by a JVM. There are lot -# of other memory areas (metadata, thread, code cache, ...) which addes to the overall +# of other memory areas (metadata, thread, code cache, ...) which adds to the overall # size. When your container gets killed because of an OOM, then you should tune # the absolute values. # JAVA_INIT_MEM_RATIO: Ratio use to calculate a default intial heap memory, in percent. @@ -254,14 +254,19 @@ run_java_options() { debug_options() { if [ -n "${JAVA_ENABLE_DEBUG:-}" ] || [ -n "${JAVA_DEBUG_ENABLE:-}" ] || [ -n "${JAVA_DEBUG:-}" ]; then - local debug_port="${JAVA_DEBUG_PORT:-5005}" + local debug_port="${JAVA_DEBUG_PORT:-5005}" local suspend_mode="n" if [ -n "${JAVA_DEBUG_SUSPEND:-}" ]; then if ! echo "${JAVA_DEBUG_SUSPEND}" | grep -q -e '^\(false\|n\|no\|0\)$'; then suspend_mode="y" fi fi - echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${debug_port}" + + local address_prefix="" + if [ "${JAVA_MAJOR_VERSION:-0}" -ge "9" ]; then + address_prefix="*:" + fi + echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${address_prefix}${debug_port}" fi } diff --git a/images/jboss/openjdk8/jdk/run-java.sh b/images/jboss/openjdk8/jdk/run-java.sh index 83a369a..e5e2731 100644 --- a/images/jboss/openjdk8/jdk/run-java.sh +++ b/images/jboss/openjdk8/jdk/run-java.sh @@ -33,7 +33,7 @@ # https://www.youtube.com/watch?v=w1rZOY5gbvk # https://vimeo.com/album/4133413/video/181900266 # Also note that heap is only a small portion of the memory used by a JVM. There are lot -# of other memory areas (metadata, thread, code cache, ...) which addes to the overall +# of other memory areas (metadata, thread, code cache, ...) which adds to the overall # size. When your container gets killed because of an OOM, then you should tune # the absolute values. # JAVA_INIT_MEM_RATIO: Ratio use to calculate a default intial heap memory, in percent. @@ -254,14 +254,19 @@ run_java_options() { debug_options() { if [ -n "${JAVA_ENABLE_DEBUG:-}" ] || [ -n "${JAVA_DEBUG_ENABLE:-}" ] || [ -n "${JAVA_DEBUG:-}" ]; then - local debug_port="${JAVA_DEBUG_PORT:-5005}" + local debug_port="${JAVA_DEBUG_PORT:-5005}" local suspend_mode="n" if [ -n "${JAVA_DEBUG_SUSPEND:-}" ]; then if ! echo "${JAVA_DEBUG_SUSPEND}" | grep -q -e '^\(false\|n\|no\|0\)$'; then suspend_mode="y" fi fi - echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${debug_port}" + + local address_prefix="" + if [ "${JAVA_MAJOR_VERSION:-0}" -ge "9" ]; then + address_prefix="*:" + fi + echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${address_prefix}${debug_port}" fi } diff --git a/images/ubi/openjdk11/jdk/Dockerfile b/images/ubi/openjdk11/jdk/Dockerfile index f1ce6ce..87708ae 100644 --- a/images/ubi/openjdk11/jdk/Dockerfile +++ b/images/ubi/openjdk11/jdk/Dockerfile @@ -1,4 +1,4 @@ -FROM registry.access.redhat.com/ubi8/ubi-minimal:8.1-398 +FROM registry.access.redhat.com/ubi8/ubi-minimal:8.2-267 USER root @@ -11,7 +11,7 @@ ENV JAVA_APP_DIR=/deployments \ # /dev/urandom is used as random source, which is prefectly safe # according to http://www.2uo.de/myths-about-urandom/ -RUN microdnf install java-11-openjdk-headless-11.0.6.10-0.el8_1 \ +RUN microdnf install java-11-openjdk-headless-11.0.7.10-1.el8_1 \ openssl curl ca-certificates \ && echo "securerandom.source=file:/dev/urandom" >> /usr/lib/jvm/jre/lib/security/java.security \ && microdnf clean all diff --git a/images/ubi/openjdk11/jdk/run-java.sh b/images/ubi/openjdk11/jdk/run-java.sh index 83a369a..e5e2731 100644 --- a/images/ubi/openjdk11/jdk/run-java.sh +++ b/images/ubi/openjdk11/jdk/run-java.sh @@ -33,7 +33,7 @@ # https://www.youtube.com/watch?v=w1rZOY5gbvk # https://vimeo.com/album/4133413/video/181900266 # Also note that heap is only a small portion of the memory used by a JVM. There are lot -# of other memory areas (metadata, thread, code cache, ...) which addes to the overall +# of other memory areas (metadata, thread, code cache, ...) which adds to the overall # size. When your container gets killed because of an OOM, then you should tune # the absolute values. # JAVA_INIT_MEM_RATIO: Ratio use to calculate a default intial heap memory, in percent. @@ -254,14 +254,19 @@ run_java_options() { debug_options() { if [ -n "${JAVA_ENABLE_DEBUG:-}" ] || [ -n "${JAVA_DEBUG_ENABLE:-}" ] || [ -n "${JAVA_DEBUG:-}" ]; then - local debug_port="${JAVA_DEBUG_PORT:-5005}" + local debug_port="${JAVA_DEBUG_PORT:-5005}" local suspend_mode="n" if [ -n "${JAVA_DEBUG_SUSPEND:-}" ]; then if ! echo "${JAVA_DEBUG_SUSPEND}" | grep -q -e '^\(false\|n\|no\|0\)$'; then suspend_mode="y" fi fi - echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${debug_port}" + + local address_prefix="" + if [ "${JAVA_MAJOR_VERSION:-0}" -ge "9" ]; then + address_prefix="*:" + fi + echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${address_prefix}${debug_port}" fi } diff --git a/images/ubi/openjdk8/jdk/Dockerfile b/images/ubi/openjdk8/jdk/Dockerfile index bebcf16..869d800 100644 --- a/images/ubi/openjdk8/jdk/Dockerfile +++ b/images/ubi/openjdk8/jdk/Dockerfile @@ -1,4 +1,4 @@ -FROM registry.access.redhat.com/ubi8/ubi-minimal:8.1-398 +FROM registry.access.redhat.com/ubi8/ubi-minimal:8.2-267 USER root @@ -11,7 +11,7 @@ ENV JAVA_APP_DIR=/deployments \ # /dev/urandom is used as random source, which is prefectly safe # according to http://www.2uo.de/myths-about-urandom/ -RUN microdnf install java-1.8.0-openjdk-headless-1.8.0.242.b08-0.el8_1 \ +RUN microdnf install java-1.8.0-openjdk-headless-1.8.0.252.b09-2.el8_1 \ openssl curl ca-certificates \ && echo "securerandom.source=file:/dev/urandom" >> /usr/lib/jvm/jre/lib/security/java.security \ && microdnf clean all diff --git a/images/ubi/openjdk8/jdk/run-java.sh b/images/ubi/openjdk8/jdk/run-java.sh index 83a369a..e5e2731 100644 --- a/images/ubi/openjdk8/jdk/run-java.sh +++ b/images/ubi/openjdk8/jdk/run-java.sh @@ -33,7 +33,7 @@ # https://www.youtube.com/watch?v=w1rZOY5gbvk # https://vimeo.com/album/4133413/video/181900266 # Also note that heap is only a small portion of the memory used by a JVM. There are lot -# of other memory areas (metadata, thread, code cache, ...) which addes to the overall +# of other memory areas (metadata, thread, code cache, ...) which adds to the overall # size. When your container gets killed because of an OOM, then you should tune # the absolute values. # JAVA_INIT_MEM_RATIO: Ratio use to calculate a default intial heap memory, in percent. @@ -254,14 +254,19 @@ run_java_options() { debug_options() { if [ -n "${JAVA_ENABLE_DEBUG:-}" ] || [ -n "${JAVA_DEBUG_ENABLE:-}" ] || [ -n "${JAVA_DEBUG:-}" ]; then - local debug_port="${JAVA_DEBUG_PORT:-5005}" + local debug_port="${JAVA_DEBUG_PORT:-5005}" local suspend_mode="n" if [ -n "${JAVA_DEBUG_SUSPEND:-}" ]; then if ! echo "${JAVA_DEBUG_SUSPEND}" | grep -q -e '^\(false\|n\|no\|0\)$'; then suspend_mode="y" fi fi - echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${debug_port}" + + local address_prefix="" + if [ "${JAVA_MAJOR_VERSION:-0}" -ge "9" ]; then + address_prefix="*:" + fi + echo "-agentlib:jdwp=transport=dt_socket,server=y,suspend=${suspend_mode},address=${address_prefix}${debug_port}" fi }