603 lines
20 KiB
Bash
Executable File
603 lines
20 KiB
Bash
Executable File
#!/bin/bash
|
|
|
|
set -eo pipefail
|
|
|
|
: "${DOWNLOAD_DIR:=${PWD}/.downloads}"
|
|
: "${PREVIEW:=false}"
|
|
: "${USE_MINECRAFT_SERVICES:=true}"
|
|
: "${DOWNLOAD_LINKS_URL:=https://net.web.minecraft-services.net/api/v1.0/download/links}"
|
|
: "${DOWNLOAD_SECONDARY_LINKS_URL:=https://net.web.minecraft-services.net/api/v1.0/download/links}"
|
|
: "${PROCESSED_DOWNLOAD_LINKS_URL:=https://raw.githubusercontent.com/kittizz/bedrock-server-downloads/refs/heads/main/bedrock-server-downloads.json}"
|
|
: "${RESOLVE_XUID_API_URL:=https://mcprofile.io/api/v1/bedrock/gamertag}"
|
|
: "${USE_BOX64:=true}"
|
|
: "${DEBUG_CURL:=false}"
|
|
: "${FORCE_PACK_COPY:=false}"
|
|
: "${FORCE_WORLD_COPY:=false}"
|
|
: "${LEVEL_NAME:=Bedrock level}"
|
|
: "${DOWNLOAD_PROGRESS:=false}"
|
|
|
|
function isTrue() {
|
|
[[ "${1,,}" =~ ^(true|on|1)$ ]] && return 0
|
|
return 1
|
|
}
|
|
|
|
function logInfo() {
|
|
msg="${1?}"
|
|
echo "INFO $msg"
|
|
}
|
|
|
|
function logWarn() {
|
|
msg="${1?}"
|
|
echo "WARN $msg" >&2
|
|
}
|
|
|
|
function logError() {
|
|
msg="${1?}"
|
|
echo "ERROR $msg" >&2
|
|
}
|
|
|
|
function resolveXuid() {
|
|
local value="${1?}"
|
|
|
|
if [[ $value =~ ^[0-9]+$ ]] && ((10#$value >= 10**15)); then
|
|
echo "$value"
|
|
return
|
|
fi
|
|
|
|
local encoded=$(jq -sRr @uri <<< "$value")
|
|
local xuid=$(curl "${debugCurlArgs[@]}" -fsSL -A "itzg/minecraft-bedrock-server" "$RESOLVE_XUID_API_URL/$encoded" 2>/dev/null | jq -r '.xuid // empty')
|
|
|
|
echo "${xuid:-$value}"
|
|
}
|
|
|
|
function resolvePermissionXuids() {
|
|
local list="$1" perm="$2"
|
|
IFS=',' read -ra a <<< "$(tr '\n' ',' <<< "$list")"
|
|
|
|
for v in "${a[@]}"; do
|
|
[[ -z $v ]] && continue
|
|
resolveXuid "$v" | jq -R --arg p "$perm" '{permission:$p,xuid:.}'
|
|
done
|
|
}
|
|
|
|
function replaceVersionInUrl() {
|
|
local original_url="${1?}"
|
|
local new_version="${2?}"
|
|
|
|
# Use sed to replace the version number in the URL
|
|
local modified_url
|
|
modified_url=$(echo "$original_url" | sed -E "s/(bedrock-server-)[^/]+(\.zip)/\1${new_version}\2/")
|
|
|
|
echo "$modified_url"
|
|
}
|
|
|
|
function versionFromExisting() {
|
|
# shellcheck disable=SC2012
|
|
# since find doesn't support sort by version numbers, -v
|
|
if [[ $(ls -rv bedrock_server-* 2> /dev/null|head -1) =~ bedrock_server-(.*) ]]; then
|
|
VERSION=${BASH_REMATCH[1]}
|
|
return 0
|
|
elif ls bedrock_server 2> /dev/null; then
|
|
VERSION=none
|
|
return 0
|
|
else
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
function lookupDownloadUrl() {
|
|
platform=${1:?Missing required platform indicator}
|
|
|
|
if isTrue "$USE_MINECRAFT_SERVICES"; then
|
|
if downloadUrl=$(lookupDownloadUrlFromMinecraftServices "$platform"); then
|
|
echo "$downloadUrl"
|
|
return 0
|
|
else
|
|
logWarn "Failed to lookup download URL from Minecraft Services, falling back to processed links"
|
|
fi
|
|
fi
|
|
|
|
# Map entry script platform arguments to the tracker's top-level keys
|
|
if [[ "$platform" == "serverBedrockPreviewLinux" ]]; then
|
|
local type="preview"
|
|
else
|
|
local type="release"
|
|
fi
|
|
|
|
if downloadUrl=$(curl "${debugCurlArgs[@]}" -fsSL "${PROCESSED_DOWNLOAD_LINKS_URL}" | \
|
|
jq --arg type "$type" -r '
|
|
.[$type]
|
|
| to_entries
|
|
| sort_by(.key | split(".") | map(tonumber))
|
|
| last
|
|
| .value.linux.url // empty
|
|
' 2>/dev/null
|
|
); then
|
|
if [[ -n "$downloadUrl" && "$downloadUrl" != "null" ]]; then
|
|
echo "$downloadUrl"
|
|
return 0
|
|
fi
|
|
fi
|
|
|
|
return 1
|
|
}
|
|
|
|
function lookupDownloadUrlFromMinecraftServices() {
|
|
platform=${1:?Missing required platform indicator}
|
|
|
|
for url in "$DOWNLOAD_LINKS_URL" "$DOWNLOAD_SECONDARY_LINKS_URL"; do
|
|
if downloadUrl=$(
|
|
curl "${debugCurlArgs[@]}" -fsSL "${url}" |
|
|
jq --arg platform "$platform" -rR '
|
|
try(fromjson) catch({}) |
|
|
.result.links // halt_error(1) |
|
|
map(
|
|
select(.downloadType == $platform)
|
|
) |
|
|
if length > 0 then
|
|
first |
|
|
.downloadUrl
|
|
else
|
|
(
|
|
"Error: could not find platform (\($platform))\n" |
|
|
stderr |
|
|
"" |
|
|
halt_error(2)
|
|
)
|
|
end
|
|
'
|
|
); then
|
|
echo "$downloadUrl"
|
|
return 0
|
|
fi
|
|
done
|
|
|
|
return 1
|
|
}
|
|
|
|
function extractVersionFromUrl() {
|
|
url=${1:?missing url}
|
|
# shellcheck disable=SC2012
|
|
if [[ ${url} =~ http.*/.*-(.*)\.zip ]]; then
|
|
echo ${BASH_REMATCH[1]}
|
|
return 0
|
|
elif versionFromExisting; then
|
|
logWarn "Minecraft download page failed, so using existing download of $VERSION"
|
|
echo $VERSION
|
|
return 0
|
|
else
|
|
logError "Failed to derive version from download URL: ${DOWNLOAD_URL}"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
function isIPv6() {
|
|
ip=${1:?}
|
|
if [[ $ip =~ ^([0-9a-fA-F]{0,4}:){2,7}[0-9a-fA-F]{0,4}$ ]]; then
|
|
return 0
|
|
else
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
function formatIpPart() {
|
|
ip=${1:?}
|
|
if isIPv6 "$ip"; then
|
|
echo "[$ip]"
|
|
else
|
|
echo "$ip"
|
|
fi
|
|
}
|
|
|
|
## @param placeholder The placeholder to replace (e.g., <public_ip>, <public_ipv4>, <public_ipv6>)
|
|
## @param publicIp The public IP address to replace the placeholder with. If empty, which will be the case if ipify is unable to resolve the requested address, the function will log an error and exit.
|
|
function replaceIpPlaceholder() {
|
|
local placeholder="${1:?}"
|
|
local publicIp="$2"
|
|
|
|
if [[ -z "$publicIp" ]]; then
|
|
logError "Unable to resolve public IP for ${placeholder}"
|
|
exit 1
|
|
fi
|
|
|
|
logInfo "Replacing ${placeholder} with ${publicIp} in SERVER_UDP_PORTS"
|
|
|
|
SERVER_UDP_PORTS="${SERVER_UDP_PORTS//${placeholder}/$(formatIpPart "$publicIp")}"
|
|
export SERVER_UDP_PORTS
|
|
}
|
|
|
|
## Evaluates the SERVER_UDP_PORTS environment variable and replaces the following placeholders:
|
|
## - <public_ip> with the public IP address (IPv4 or IPv6) of the server
|
|
## - <public_ipv4> with the public IPv4 address of the server
|
|
## - <public_ipv6> with the public IPv6 address of the server
|
|
## If one of the specific placeholders does not resolve, then the startup will exit
|
|
function manageServerUdpPorts() {
|
|
if [[ "$SERVER_UDP_PORTS" == *"<public_ip>"* ]]; then
|
|
replaceIpPlaceholder "<public_ip>" "$(curl -s https://api64.ipify.org)"
|
|
elif [[ "$SERVER_UDP_PORTS" == *"<public_ipv4>"* ]]; then
|
|
replaceIpPlaceholder "<public_ipv4>" "$(curl -s https://api.ipify.org)"
|
|
elif [[ "$SERVER_UDP_PORTS" == *"<public_ipv6>"* ]]; then
|
|
replaceIpPlaceholder "<public_ipv6>" "$(curl -s https://api6.ipify.org)"
|
|
fi
|
|
}
|
|
|
|
function manageProperties() {
|
|
manageServerUdpPorts
|
|
|
|
if [[ -n "$VARIABLES" ]]; then
|
|
echo "Setting variables"
|
|
mkdir -p config/default
|
|
|
|
# Try to parse VARIABLES as JSON
|
|
if echo "$VARIABLES" | jq empty >/dev/null 2>&1; then
|
|
# VARIABLES is valid JSON
|
|
echo "$VARIABLES" | jq '.' > "config/default/variables.json"
|
|
else
|
|
# VARIABLES is not valid JSON, attempt to parse as custom format
|
|
echo "VARIABLES is not valid JSON, attempting to parse as custom format"
|
|
|
|
# Parse the VARIABLES using custom format (key:value,key:value)
|
|
# Note: Values should not contain unescaped commas or colons
|
|
jq -n --arg vars "$VARIABLES" '
|
|
$vars
|
|
| split("[,\\n]+"; "")
|
|
| map(
|
|
select(length>0) |
|
|
split("=") as $kv |
|
|
{ ($kv[0]): ($kv[1] | fromjson? // $kv[1]) }
|
|
)
|
|
| add
|
|
' > "config/default/variables.json"
|
|
fi
|
|
fi
|
|
|
|
|
|
if [ -f server.properties ]; then
|
|
# prevent issue with bind mounted server.properties which can not be moved (sed tries to move the file when '-i' is used)
|
|
_SERVER_PROPERTIES=$(sed '/^white-list=.*/d' server.properties) #Removes white-list= line from server.properties
|
|
echo "${_SERVER_PROPERTIES}" > server.properties
|
|
fi
|
|
export ALLOW_LIST
|
|
|
|
# update server.properties with environment settings
|
|
set-property --file server.properties --bulk /etc/bds-property-definitions.json
|
|
}
|
|
|
|
#######################################################################################################################
|
|
# MAIN
|
|
#######################################################################################################################
|
|
|
|
echo "Image info: $(paste -d, -s /etc/image.properties)"
|
|
|
|
debugCurlArgs=()
|
|
if [[ ${DEBUG^^} == TRUE ]]; then
|
|
set -x
|
|
debugCurlArgs+=(-v)
|
|
echo "DEBUG: running as $(id -a) with $(ls -ld /data)"
|
|
echo " current directory is $(pwd)"
|
|
fi
|
|
|
|
export HOME="${PWD}"
|
|
export TMPDIR="${HOME}/.tmp"
|
|
mkdir -p "${TMPDIR}"
|
|
|
|
if [[ ${EULA^^} != TRUE ]]; then
|
|
echo
|
|
echo "EULA must be set to TRUE to indicate agreement with the Minecraft End User License"
|
|
echo "See https://minecraft.net/terms"
|
|
echo
|
|
echo "Current value is '${EULA}'"
|
|
echo
|
|
exit 1
|
|
fi
|
|
|
|
# Check for DIRECT_DOWNLOAD_URL override first
|
|
if [[ -n "${DIRECT_DOWNLOAD_URL}" ]]; then
|
|
echo "Using direct download URL from DIRECT_DOWNLOAD_URL environment variable."
|
|
DOWNLOAD_URL="${DIRECT_DOWNLOAD_URL}"
|
|
# If VERSION is not explicitly set, try to extract it from the URL
|
|
if [[ -z "${VERSION}" ]]; then
|
|
if [[ "${DOWNLOAD_URL}" =~ bedrock-server-([0-9\.]+)\.zip ]]; then
|
|
VERSION=${BASH_REMATCH[1]}
|
|
echo "Extracted VERSION=${VERSION} from DIRECT_DOWNLOAD_URL."
|
|
else
|
|
echo "WARNING: Could not extract VERSION from DIRECT_DOWNLOAD_URL. Please ensure VERSION environment variable is set."
|
|
# Optionally exit here if VERSION is strictly required, but for testing, often the test will fail later.
|
|
fi
|
|
else
|
|
echo "VERSION=${VERSION} is explicitly set, using it with DIRECT_DOWNLOAD_URL."
|
|
fi
|
|
else # Original logic: if DIRECT_DOWNLOAD_URL is NOT set, proceed with lookup
|
|
case ${VERSION^^} in
|
|
PREVIEW)
|
|
echo "Looking up latest preview version..."
|
|
if ! DOWNLOAD_URL=$(lookupDownloadUrl serverBedrockPreviewLinux); then
|
|
logError " failed to lookup download URL"
|
|
exit 1
|
|
fi
|
|
VERSION=$(extractVersionFromUrl "$DOWNLOAD_URL")
|
|
;;
|
|
LATEST)
|
|
echo "Looking up latest version..."
|
|
if ! DOWNLOAD_URL=$(lookupDownloadUrl serverBedrockLinux); then
|
|
logError "failed to lookup download URL"
|
|
exit 1
|
|
fi
|
|
VERSION=$(extractVersionFromUrl "$DOWNLOAD_URL")
|
|
;;
|
|
EXISTING)
|
|
if versionFromExisting; then
|
|
echo "Using existing bedrock server executable"
|
|
else
|
|
logError " unable to locate existing bedrock server executable"
|
|
exit 1
|
|
fi
|
|
;;
|
|
*)
|
|
if isTrue "$PREVIEW"; then
|
|
echo "Using given preview version ${VERSION}"
|
|
if ! DOWNLOAD_URL=$(lookupDownloadUrl serverBedrockPreviewLinux); then
|
|
logError " failed to lookup Bedrock version and download URL"
|
|
exit 1
|
|
fi
|
|
DOWNLOAD_URL=$(replaceVersionInUrl "${DOWNLOAD_URL}" "${VERSION}")
|
|
else
|
|
echo "Using given version ${VERSION}"
|
|
if ! DOWNLOAD_URL=$(lookupDownloadUrl serverBedrockLinux); then
|
|
logError " failed to lookup Bedrock version and download URL"
|
|
exit 1
|
|
fi
|
|
DOWNLOAD_URL=$(replaceVersionInUrl "${DOWNLOAD_URL}" "${VERSION}")
|
|
fi
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
if [[ $VERSION = none ]]; then
|
|
SERVER=bedrock_server
|
|
else
|
|
SERVER="bedrock_server-${VERSION}"
|
|
fi
|
|
|
|
if [[ ! -f "$SERVER" ]]; then
|
|
|
|
[[ $DOWNLOAD_DIR != /tmp ]] && mkdir -p "$DOWNLOAD_DIR"
|
|
TMP_ZIP="$DOWNLOAD_DIR/$(basename "${DOWNLOAD_URL}")"
|
|
|
|
echo "Downloading Bedrock server version ${VERSION} ..."
|
|
curlProgressArgs=(-fsSL)
|
|
if isTrue "$DOWNLOAD_PROGRESS"; then
|
|
curlProgressArgs=(-fL --progress-bar)
|
|
fi
|
|
if ! curl "${debugCurlArgs[@]}" "${curlProgressArgs[@]}" -o "${TMP_ZIP}" -A "itzg/minecraft-bedrock-server" "${DOWNLOAD_URL}"; then
|
|
logError " failed to download from ${DOWNLOAD_URL}
|
|
Double check that the given VERSION is valid"
|
|
exit 2
|
|
fi
|
|
|
|
# remove only binaries and some docs, to allow for an upgrade of those
|
|
rm -rf -- bedrock_server bedrock_server-* *.so release-notes.txt bedrock_server_how_to.html valid_known_packs.json premium_cache 2> /dev/null
|
|
|
|
bkupDir=backup-pre-${VERSION}
|
|
# fixup any previous interrupted upgrades
|
|
rm -rf "${bkupDir}"
|
|
for d in behavior_packs definitions minecraftpe resource_packs structures treatments world_templates; do
|
|
if [[ -d $d && -n "$(ls $d)" ]]; then
|
|
mkdir -p "${bkupDir}/$d"
|
|
echo "Backing up $d into $bkupDir"
|
|
if [[ "$d" == "resource_packs" ]]; then
|
|
# Copy over resource packs to ensure user-supplied ones remain
|
|
cp -a $d/* "${bkupDir}/$d/"
|
|
|
|
# ...however, need to fully remove Mojang provided resource packs to ensure consistent content
|
|
for rp_dir in chemistry vanilla editor; do
|
|
if [[ -d "$d/$rp_dir" ]]; then
|
|
# shellcheck disable=SC2115
|
|
rm -rf "$d/$rp_dir"
|
|
fi
|
|
done
|
|
elif [[ "$d" == "behavior_packs" ]]; then
|
|
# remove Mojang provided ones
|
|
find behavior_packs \( -name 'vanilla*' -o -name 'chemistry*' -o -name 'experimental*' \) -exec rm -rf {} +
|
|
else
|
|
mv $d "${bkupDir}/"
|
|
fi
|
|
fi
|
|
done
|
|
|
|
# remove old package backups, but keep PACKAGE_BACKUP_KEEP
|
|
if (( ${PACKAGE_BACKUP_KEEP:=2} >= 0 )); then
|
|
shopt -s nullglob
|
|
# shellcheck disable=SC2012
|
|
for d in $( ls -td1 backup-pre-* | tail +$(( PACKAGE_BACKUP_KEEP + 1 )) ); do
|
|
echo "Pruning backup directory: $d"
|
|
rm -rf "$d"
|
|
done
|
|
fi
|
|
|
|
# Do not overwrite existing files, which means the cleanup above needs to account for things
|
|
# that MUST be replaced on upgrade
|
|
unzip -q -n "${TMP_ZIP}"
|
|
[[ $DOWNLOAD_DIR != /tmp ]] && rm -rf "$DOWNLOAD_DIR"
|
|
|
|
chmod +x bedrock_server
|
|
mv bedrock_server "$SERVER"
|
|
fi
|
|
|
|
if [[ -n "${MC_PACK:-}" ]]; then
|
|
finallyShopt="$(shopt -p nullglob || true)"
|
|
shopt -s nullglob
|
|
if [[ -d "$MC_PACK" ]]; then
|
|
srcDir="$MC_PACK"
|
|
cleanupTmp=
|
|
elif [[ -f "$MC_PACK" ]]; then
|
|
srcDir=$(mktemp -d)
|
|
cleanupTmp=1
|
|
unzip -q -o "$MC_PACK" -d "$srcDir"
|
|
else
|
|
logWarn "MC_PACK is set but path does not exist or is not a file/directory: $MC_PACK"
|
|
srcDir=
|
|
fi
|
|
if [[ -n "$srcDir" ]]; then
|
|
if [[ ! -d "$srcDir/behavior_packs" && ! -d "$srcDir/resource_packs" ]] && \
|
|
[[ -f "$srcDir/data/manifest.json" || -f "$srcDir/resources/manifest.json" ]]; then
|
|
for subdir in data resources; do
|
|
packManifestFile="$srcDir/$subdir/manifest.json"
|
|
if [[ ! -f "$packManifestFile" ]]; then
|
|
continue;
|
|
fi
|
|
|
|
packId=$(jq -r '.header.uuid' "$packManifestFile")
|
|
destName="behavior_packs"; [[ "$subdir" == "resources" ]] && destName="resource_packs"
|
|
|
|
worldPacksFile="$srcDir/world_${destName}.json"
|
|
worldPacksJson=$(jq -c '[{pack_id: .header.uuid, version: .header.version}]' "$packManifestFile")
|
|
|
|
mkdir -p "$srcDir/$destName"
|
|
mv "$srcDir/$subdir" "$srcDir/$destName/$packId"
|
|
echo "$worldPacksJson" > "$worldPacksFile" && echo "Generated $worldPacksFile as $worldPacksJson"
|
|
done
|
|
fi
|
|
if [[ -d "$srcDir/addon" ]]; then
|
|
for addonSub in "$srcDir/addon"/*; do
|
|
packManifestFile="$addonSub/manifest.json"
|
|
if [[ ! -f "$packManifestFile" ]]; then
|
|
logWarn "addon/$(basename "$addonSub"): manifest.json not found; skipping";
|
|
continue;
|
|
fi
|
|
packId=$(jq -r '.header.uuid' "$packManifestFile")
|
|
packKind=$(jq -r '
|
|
[ .modules[]?.type ] as $types
|
|
| if ($types | any(IN("data","script"))) then "behavior_packs"
|
|
elif ($types | any(. == "resources")) then "resource_packs"
|
|
else empty
|
|
end
|
|
' "$packManifestFile")
|
|
if [[ -z "$packId" || "$packId" == "null" || -z "$packKind" ]]; then
|
|
logWarn "addon/$(basename "$addonSub"): unsupported manifest modules; skipping";
|
|
continue;
|
|
fi
|
|
dest="$srcDir/$packKind/$packId"
|
|
[[ -d "$dest" ]] && rm -rf "$dest"
|
|
mkdir -p "$srcDir/$packKind" && mv "$addonSub" "$dest" && echo "Moved addon $(basename "$addonSub") to $packKind/$packId"
|
|
done
|
|
rm -rf "$srcDir/addon"
|
|
fi
|
|
for dir in behavior_packs resource_packs; do
|
|
if [[ -d "$srcDir/$dir" ]]; then
|
|
mkdir -p "$dir"
|
|
for sub in "$srcDir/$dir"/*; do
|
|
destSub="$dir/$(basename "$sub")"
|
|
if isTrue "$FORCE_PACK_COPY" && [[ -d "$destSub" ]]; then
|
|
logWarn "Removing existing pack at $destSub (FORCE_PACK_COPY=TRUE)"
|
|
rm -rf "$destSub"
|
|
fi
|
|
[[ ! -d "$destSub" ]] && echo "Copying pack $(basename "$sub") to $dir" && cp -a "$sub" "$dir/"
|
|
done
|
|
fi
|
|
done
|
|
levelDir="worlds/$LEVEL_NAME"
|
|
if [[ -f "$srcDir/level.dat" ]]; then
|
|
if isTrue "$FORCE_WORLD_COPY" || [[ ! -f "$levelDir/level.dat" ]]; then
|
|
if isTrue "$FORCE_WORLD_COPY" && [[ -d "$levelDir" ]]; then
|
|
logWarn "Removing existing world at $levelDir (FORCE_WORLD_COPY=TRUE)"
|
|
rm -rf "$levelDir"
|
|
fi
|
|
for item in "$srcDir"/*; do
|
|
name=$(basename "$item")
|
|
if [[ "$name" == "behavior_packs" || "$name" == "resource_packs" || "$name" == "addon" ]]; then
|
|
continue;
|
|
fi
|
|
mkdir -p "$levelDir"
|
|
echo "Copying world item $name to $levelDir"
|
|
cp -a "$item" "$levelDir/"
|
|
done
|
|
fi
|
|
fi
|
|
[[ -n "$cleanupTmp" ]] && rm -rf "$srcDir"
|
|
fi
|
|
eval "$finallyShopt"
|
|
fi
|
|
|
|
if [[ -n "$OPS" || -n "$MEMBERS" || -n "$VISITORS" ]]; then
|
|
echo "Updating permissions"
|
|
{
|
|
resolvePermissionXuids "$OPS" operator
|
|
resolvePermissionXuids "$MEMBERS" member
|
|
resolvePermissionXuids "$VISITORS" visitor
|
|
} | jq -s '.' > permissions.json
|
|
fi
|
|
|
|
if [[ -n "$ALLOW_LIST_USERS" || -n "$WHITE_LIST_USERS" ]]; then
|
|
allowListUsers=${ALLOW_LIST_USERS:-$WHITE_LIST_USERS}
|
|
|
|
if [[ "$allowListUsers" ]]; then
|
|
echo "Setting allow list"
|
|
if [[ "$allowListUsers" != *":"* ]]; then
|
|
jq -c -n --arg users "$allowListUsers" '$users | split("[,\\n]+"; "") | map(select(length>0) | {"ignoresPlayerLimit":false,"name": .})' > "allowlist.json"
|
|
else
|
|
jq -c -n --arg users "$allowListUsers" '$users | split("[,\\n]+"; "") | map(select(length>0) | split(":") | {"ignoresPlayerLimit":false,"name": .[0], "xuid": .[1]})' > "allowlist.json"
|
|
fi
|
|
# activate server property to enable list usage
|
|
ALLOW_LIST=true
|
|
else
|
|
ALLOW_LIST=false
|
|
rm -f allowlist.json
|
|
fi
|
|
fi
|
|
|
|
manageProperties
|
|
|
|
export LD_LIBRARY_PATH=.
|
|
|
|
: "${ENABLE_BDS_V6BIND_FIX:=false}"
|
|
if isTrue "${ENABLE_BDS_V6BIND_FIX}"; then
|
|
if [[ -f /opt/bds-ipv6fix.so ]]; then
|
|
export LD_PRELOAD=/opt/bds-ipv6fix.so
|
|
else
|
|
echo "WARNING: ENABLE_BDS_V6BIND_FIX=true but bds-ipv6fix.so is not available for this platform"
|
|
fi
|
|
fi
|
|
|
|
mcServerRunnerArgs=()
|
|
if isTrue "${ENABLE_SSH}"; then
|
|
mcServerRunnerArgs+=(--remote-console)
|
|
if [[ -v REMOTE_CONSOLE_BIND_ADDRESS ]]; then
|
|
mcServerRunnerArgs+=(--remote-console-bind-address "${REMOTE_CONSOLE_BIND_ADDRESS}")
|
|
fi
|
|
if ! [[ -v RCON_PASSWORD ]]; then
|
|
RCON_PASSWORD=$(openssl rand -hex 12)
|
|
export RCON_PASSWORD
|
|
fi
|
|
|
|
# For ssh access by tools, export the current password.
|
|
# Use rcon's format to align with Java, as Java uses the rcon password for SSH as well.
|
|
echo "password=${RCON_PASSWORD}" > "$HOME/.remote-console.env"
|
|
echo "password: \"${RCON_PASSWORD}\"" > "$HOME/.remote-console.yaml"
|
|
fi
|
|
|
|
echo "Starting Bedrock server..."
|
|
if [[ -f /usr/local/bin/box64 ]] && isTrue "${USE_BOX64:=false}" ; then
|
|
exec mc-server-runner "${mcServerRunnerArgs[@]}" box64 ./"$SERVER"
|
|
elif [[ -x /usr/bin/FEX ]] && isTrue "${USE_FEX:=true}" ; then
|
|
# FEX-Emu (x86_64 on arm64): RootFS and emulator are baked into the image.
|
|
# FEX_EMU_DIR holds the JIT/AOT caches — keep it on a volume for warm starts.
|
|
# FEX >= 2611: unified launcher is /usr/bin/FEX (FEXInterpreter was removed).
|
|
export FEX_ROOTFS="${FEX_ROOTFS:-/opt/fex-emu-rootfs/rootfs}"
|
|
export FEX_EMU_DIR="${FEX_EMU_DIR:-$HOME/.fex-emu}"
|
|
mkdir -p "$FEX_EMU_DIR"
|
|
if [[ ! -f "$HOME/.config/fex-emu/Config.json" ]]; then
|
|
mkdir -p "$HOME/.config/fex-emu"
|
|
cat > "$HOME/.config/fex-emu/Config.json" << 'FEXCONF'
|
|
{
|
|
"Options": [
|
|
{ "Key": "RootFS", "Value": "/opt/fex-emu-rootfs/rootfs" }
|
|
]
|
|
}
|
|
FEXCONF
|
|
fi
|
|
exec mc-server-runner "${mcServerRunnerArgs[@]}" /usr/bin/FEX ./"$SERVER"
|
|
else
|
|
exec mc-server-runner "${mcServerRunnerArgs[@]}" ./"$SERVER"
|
|
fi
|