tdlight-team/tdlight-java-natives
1
0
Fork 0
Code Issues 1 Pull Requests Releases Wiki Activity

Code cleanup

Browse Source
This commit is contained in:
Andrea Cavalli 2023-05-15 00:43:49 +02:00
parent ee360753e4
commit 6d5522d05e
28 changed files with 2 additions and 1426 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
Dockerfile
View File

@ -1,42 +0,0 @@
ARG GH_MATRIX_SSL
ARG GH_CROSSBUILD
FROM debian:buster as img_ssl1
ONBUILD ENV SSL_LIB_NAME=libssl1.1
FROM debian:bookworm as img_ssl3
ONBUILD ENV SSL_LIB_NAME=libssl3
FROM img_${GH_MATRIX_SSL} AS build
ARG REVISION
ARG GH_MATRIX_OS
ARG GH_MATRIX_ARCH
ARG GH_MATRIX_SSL
ARG IMPLEMENTATION_NAME
ARG CPU_CORES_NUM
ARG GH_CROSSBUILD
ENV DEBIAN_FRONTEND noninteractive
ENV TZ=Europe/Kiev
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
ENV LANG "en_US.UTF-8"
ENV JAVA_TOOL_OPTIONS "-Dfile.encoding=UTF8"
ENV CROSS_BUILD_DEPS_DIR "/var/cache/crossbuild-deps"
ADD implementations /usr/src/tdlight-java-natives/implementations
ADD scripts /usr/src/tdlight-java-natives/scripts
ADD src /usr/src/tdlight-java-natives/src
WORKDIR /usr/src/tdlight-java-natives/
RUN --mount=target=/var/lib/apt/lists,type=cache,sharing=locked \
--mount=target=/var/cache/apt,type=cache,sharing=locked \
--mount=target=/var/cache/crossbuild-deps,type=cache,sharing=locked \
/bin/bash /usr/src/tdlight-java-natives/scripts/continuous-integration/docker/install-dependencies.sh
RUN --mount=target=/var/lib/apt/lists,type=cache,sharing=locked \
--mount=target=/var/cache/apt,type=cache,sharing=locked \
--mount=target=/var/cache/crossbuild-deps,type=cache,sharing=locked \
/bin/bash /usr/src/tdlight-java-natives/scripts/continuous-integration/docker/build-natives.sh
ENTRYPOINT [ "/bin/bash" ]

6
README.md
View File

@ -4,11 +4,9 @@ This repository generates JNI packages for each architecture and OS used by [TDL
## Building
Go to `scripts/utils` and run
**todo**
- `./compile-natives-package.sh` for natives
- `./compile-tdapi-package.sh` for tdapi
look at .github/workflows/scripts/build_linux_amd64_ssl1.sh, it's a decent example
## Download

16
scripts/continuous-integration/docker/build-natives.sh
View File

@ -1,16 +0,0 @@
#!/bin/bash -e
source ./scripts/continuous-integration/docker/setup-platform-variables.sh
export JAVA_HOME
JAVA_HOME="$(find "/usr/lib/jvm/" -maxdepth 1 -type d -iname "java*jdk*" | head -n 1)/"
export JAVA_INCLUDE_PATH="$JAVA_HOME/include"
cd scripts/core
source ./setup-variables.sh
./install-dependencies.sh
./generate_maven_project.sh
./generate_td_tools.sh
./configure_td.sh
./compile_td.sh
./compile_tdjni.sh
./build_generated_maven_project.sh

117
scripts/continuous-integration/docker/install-dependencies.sh
View File

@ -1,117 +0,0 @@
source ./scripts/continuous-integration/docker/setup-platform-variables.sh
# Check variables correctness
if [ -z "${CPU_ARCH_DPKG}" ]; then
echo "Missing parameter: CPU_ARCH_DPKG"
exit 1
fi
OJDK_VERSION_NUMBER="11"
if [[ "$GH_MATRIX_SSL" == "ssl3" ]]; then
OJDK_VERSION_NUMBER="17"
fi
install_deps() {
apt-get install -y sudo build-essential openjdk-${OJDK_VERSION_NUMBER}-jdk locales wget cmake gperf ccache maven \
libssl-dev ${SSL_LIB_NAME} zlib1g-dev zlib1g "crossbuild-essential-${CPU_ARCH_DPKG}"
sed -i -e 's/# en_US.UTF-8 UTF-8/en_US.UTF-8 UTF-8/' /etc/locale.gen && \
dpkg-reconfigure --frontend=noninteractive locales && \
update-locale LANG=en_US.UTF-8
}
if [ -n "${CROSS_BUILD_DEPS_DIR}" ]; then
CROSS_OPENJDK_PATH=""
fix_jdk_path() {
# Setup OpenJDK path
CROSS_OPENJDK_PATH=$(find "$CROSS_BUILD_DEPS_DIR/usr/lib/jvm/" -maxdepth 1 -type d -iname "java*jdk*" | head -n 1)
}
check_jdk_existance() {
if [[ ! -d "$CROSS_OPENJDK_PATH" ]]; then
echo "Can't find cross OpenJDK at location $CROSS_OPENJDK_PATH"
exit 1
fi
}
PWD_BEFORE_CROSS_DEPS=$(pwd)
if [[ ! -f "$CROSS_BUILD_DEPS_DIR/ok-013" ]]; then
echo "Setting up cross build deps dir"
find "$CROSS_BUILD_DEPS_DIR" -mindepth 1 -delete || true
mkdir -p "$CROSS_BUILD_DEPS_DIR"
cd "$CROSS_BUILD_DEPS_DIR"
dpkg --add-architecture "${CPU_ARCH_DPKG}"
apt-get update
# LibZ-Dev
apt-get download "zlib1g-dev:${CPU_ARCH_DPKG}"
ZLIB1G_DEV_DEB=$(find . -name "zlib1g-dev_*.deb")
dpkg -x "$ZLIB1G_DEV_DEB" "$CROSS_BUILD_DEPS_DIR"
rm "$ZLIB1G_DEV_DEB"
# LibZ
apt-get download "zlib1g:${CPU_ARCH_DPKG}"
ZLIB1G_DEB=$(find . -name "zlib1g_*.deb")
dpkg -x "$ZLIB1G_DEB" "$CROSS_BUILD_DEPS_DIR"
rm "$ZLIB1G_DEB"
# LibSSL-Dev
apt-get download "libssl-dev:${CPU_ARCH_DPKG}"
LIBSSL_DEV_DEB=$(find . -name "libssl-dev_*.deb")
dpkg -x "$LIBSSL_DEV_DEB" "$CROSS_BUILD_DEPS_DIR"
rm "$LIBSSL_DEV_DEB"
if [[ "$GH_MATRIX_SSL" == "ssl3" ]]; then
# LibSSL
apt-get download "libssl3:${CPU_ARCH_DPKG}"
LIBSSL_DEB=$(find . -name "libssl3_*.deb")
dpkg -x "$LIBSSL_DEB" "$CROSS_BUILD_DEPS_DIR"
else
# LibSSL
apt-get download "libssl1.1:${CPU_ARCH_DPKG}"
LIBSSL_DEB=$(find . -name "libssl1.1_*.deb")
dpkg -x "$LIBSSL_DEB" "$CROSS_BUILD_DEPS_DIR"
fi
rm "$LIBSSL_DEB"
# Java Common
apt-get download "java-common"
JC_DEB=$(find . -name "java-common_*.deb")
dpkg -x "$JC_DEB" "$CROSS_BUILD_DEPS_DIR"
rm "$JC_DEB"
# OpenJDK-JRE-Headless
apt-get download "openjdk-${OJDK_VERSION_NUMBER}-jre-headless:${CPU_ARCH_DPKG}"
OJDKRH_DEB=$(find . -name "openjdk-${OJDK_VERSION_NUMBER}-jre-headless_*.deb")
dpkg -x "$OJDKRH_DEB" "$CROSS_BUILD_DEPS_DIR"
rm "$OJDKRH_DEB"
# OpenJDK-JRE
apt-get download "openjdk-${OJDK_VERSION_NUMBER}-jre:${CPU_ARCH_DPKG}"
OJDKR_DEB=$(find . -name "openjdk-${OJDK_VERSION_NUMBER}-jre_*.deb")
dpkg -x "$OJDKR_DEB" "$CROSS_BUILD_DEPS_DIR"
rm "$OJDKR_DEB"
# OpenJDK-JDK
apt-get download "openjdk-${OJDK_VERSION_NUMBER}-jdk-headless:${CPU_ARCH_DPKG}"
OJDKJ_DEB=$(find . -name "openjdk-${OJDK_VERSION_NUMBER}-jdk-headless_*.deb")
dpkg -x "$OJDKJ_DEB" "$CROSS_BUILD_DEPS_DIR"
rm "$OJDKJ_DEB"
# OpenJDK-GUI
apt-get download "openjdk-${OJDK_VERSION_NUMBER}-jdk:${CPU_ARCH_DPKG}"
OJDKG_DEB=$(find . -name "openjdk-${OJDK_VERSION_NUMBER}-jdk_*.deb")
dpkg -x "$OJDKG_DEB" "$CROSS_BUILD_DEPS_DIR"
rm "$OJDKG_DEB"
# Fix symlinks
find "$CROSS_BUILD_DEPS_DIR" -lname "/*" \
-exec sh -c "ln -sf \"\`echo \"$CROSS_BUILD_DEPS_DIR\$(readlink \$0)\"\`\" \"\$0\"" {} \;
echo "Cross build deps dir setup finished, testing..."
# Check if openjdk is found
fix_jdk_path
check_jdk_existance
touch "$CROSS_BUILD_DEPS_DIR/ok-013"
else
apt-get update
fi
install_deps
echo "Cross build deps dir setup done"
fix_jdk_path
check_jdk_existance
cd "${PWD_BEFORE_CROSS_DEPS}"
else
apt-get update
install_deps
fi

10
scripts/continuous-integration/docker/setup-platform-variables.sh
View File

@ -1,10 +0,0 @@
#!/bin/bash -e
if [[ -n ${GH_CROSSBUILD} ]]; then
export CROSS_BUILD_DEPS_DIR=""
fi
source ./scripts/continuous-integration/github-workflows/setup-variables.sh
export JAVA_HOME
JAVA_HOME="$(find "/usr/lib/jvm/" -maxdepth 1 -type d -iname "java*jdk*" | head -n 1)/"
export JAVA_INCLUDE_PATH="$JAVA_HOME/include"

12
scripts/continuous-integration/github-workflows/build-natives.sh
View File

@ -1,12 +0,0 @@
#!/bin/bash -e
set -e
cd ./scripts/core/
./generate_maven_project.sh
./generate_td_tools.sh
./configure_td.sh
./compile_td.sh
./compile_tdjni.sh
./build_generated_maven_project.sh
echo "Done."
exit 0

16
scripts/continuous-integration/github-workflows/build-tdapi.sh
View File

@ -1,16 +0,0 @@
#!/bin/bash -e
set -e
cd ./scripts/core/
./generate_td_tools.sh
./configure_td.sh
API_TYPE=legacy ./generate_tdapi_maven_project.sh
API_TYPE=legacy ./generate_tdapi_java_file.sh
API_TYPE=legacy ./build_generated_tdapi_maven_project.sh
API_TYPE=sealed ./generate_tdapi_maven_project.sh
API_TYPE=sealed ./generate_tdapi_java_file.sh
API_TYPE=sealed ./build_generated_tdapi_maven_project.sh
echo "Done."
exit 0

29
scripts/continuous-integration/github-workflows/deploy-javadoc.sh
View File

@ -1,29 +0,0 @@
#!/bin/bash -e
set -e
# Check variables correctness
if [ -z "${IMPLEMENTATION_NAME}" ]; then
echo "Missing parameter: IMPLEMENTATION_NAME"
exit 1
fi
if [ -z "${API_TYPE}" ]; then
echo "Missing parameter: API_TYPE"
exit 1
fi
cd "./generated-${API_TYPE}/target/apidocs"
find . -name '*.html' -exec sed -i -r 's/<\/title>/<\/title>\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\"><style>\n\t#memberSummary_tabpanel{overflow-x: auto;}\n\tli.blockList{overflow-x: auto;}\n\ttd.colLast div{max-width:30vw;}\n\t#search{width: 400px;max-width: 65vw;}\n\t.title,.subTitle,pre,.inheritance,h1,h2,h3,h4,h5,.memberSummary,.memberSignature,.typeSummary,.blockList,.contentContainer{white-space:normal;word-break:break-word;}\n\tul{padding-left:10px}\n<\/style>/' {} \;
git config --global init.defaultBranch master
git init
git checkout -b "${IMPLEMENTATION_NAME}-${API_TYPE}"
git remote add origin "https://${DOCS_DEPLOY_USERNAME}:${DOCS_DEPLOY_PASSWORD}@git.ignuranza.net/tdlight-team/tdlight-docs"
git config user.email "andrea@warp.ovh"
git config user.name "Andrea Cavalli"
git fetch --all
git reset --soft "origin/${IMPLEMENTATION_NAME}-${API_TYPE}" || true
git add -A
git commit -m "Update javadocs"
git push --set-upstream origin "${IMPLEMENTATION_NAME}-${API_TYPE}"
echo "Done."
exit 0

7
scripts/continuous-integration/github-workflows/deploy-release.sh
View File

@ -1,7 +0,0 @@
#!/bin/bash -e
set -e
cd ./scripts/core/
./deploy_release.sh
echo "Done."
exit 0

7
scripts/continuous-integration/github-workflows/deploy-snapshot.sh
View File

@ -1,7 +0,0 @@
#!/bin/bash -e
set -e
cd ./scripts/core/
./deploy_snapshot.sh
echo "Done."
exit 0

31
scripts/continuous-integration/github-workflows/install-dependencies.sh
View File

@ -1,31 +0,0 @@
#!/bin/bash -e
set -e
if [[ "$OPERATING_SYSTEM_NAME" == "linux" ]]; then
echo "==Linux===="
sudo apt-get update
sudo apt-get install -y make gperf \
ccache python3 python3-pip php-cli \
build-essential gcc-multilib g++-multilib
elif [[ "$OPERATING_SYSTEM_NAME" == "osx" ]]; then
echo "==OSX======"
brew update
brew install gperf cmake openssl coreutils
brew install openjdk
brew install freetype gd libtiff
elif [[ "$OPERATING_SYSTEM_NAME" == "windows" ]]; then
echo "==Windows=="
#choco install visualstudio2019buildtools --version=16.10.4.0 --allow-downgrade --package-parameters "--passive"
#choco install visualstudio2019-workload-vctools
choco install base64
choco install gperf
choco install strawberryperl
else
echo "Unrecognized os: $OPERATING_SYSTEM_NAME"
exit 1
fi
cd ./scripts/core/
./install-dependencies.sh
cd ../../

115
scripts/continuous-integration/github-workflows/setup-variables.sh
View File

@ -1,115 +0,0 @@
#!/bin/bash -e
set -e
export MAVEN_OPTS=""
echo "MATRIX_OS: $GH_MATRIX_OS"
echo "MATRIX_ARCH: $GH_MATRIX_ARCH"
if [ "$GH_MATRIX_OS" == "macos-10.15" ]; then
export PCRE="E"
else
export PCRE="r"
fi
GH_CPU_ARCH=$(echo "$GH_MATRIX_ARCH" | sed -$PCRE 's/^(linux\/|windows\/|macos\/)?(386|amd64|arm64|ppc64le|armhf|s390x)$/\2/g')
export GH_CPU_ARCH
GH_OS_NAME=$(echo "$GH_MATRIX_OS" | sed -$PCRE 's/^(linux|ubuntu|windows|macos).*$/\1/g')
if [[ $GH_OS_NAME == "ubuntu" ]]; then
GH_OS_NAME="linux"
fi
export GH_OS_NAME
if [[ "$GH_CPU_ARCH" == "arm64" ]]; then
export CPU_ARCHITECTURE_NAME="aarch64"
elif [[ "$GH_CPU_ARCH" == "armhf" ]]; then
export CPU_ARCHITECTURE_NAME="armhf"
elif [[ "$GH_CPU_ARCH" == "s390x" ]]; then
export CPU_ARCHITECTURE_NAME="s390x"
elif [[ "$GH_CPU_ARCH" == "386" ]]; then
export CPU_ARCHITECTURE_NAME="386"
elif [[ "$GH_CPU_ARCH" == "amd64" ]]; then
export CPU_ARCHITECTURE_NAME="amd64"
elif [[ "$GH_CPU_ARCH" == "ppc64le" ]]; then
export CPU_ARCHITECTURE_NAME="ppc64le"
else
echo "Unrecognized cpu arch: $GH_CPU_ARCH"
exit 1
fi
if [ -z "${CPU_CORES_NUM}" ]; then
export CPU_CORES_NUM="4"
fi
if [[ "$GH_OS_NAME" == "windows" ]]; then
export OPERATING_SYSTEM_NAME="windows"
export OPERATING_SYSTEM_NAME_SHORT="win"
elif [[ "$GH_OS_NAME" == "macos" ]]; then
export OPERATING_SYSTEM_NAME="osx"
export OPERATING_SYSTEM_NAME_SHORT="osx"
elif [[ "$GH_OS_NAME" == "linux" ]]; then
export OPERATING_SYSTEM_NAME="linux"
export OPERATING_SYSTEM_NAME_SHORT="linux"
else
echo "Unrecognized os name: $GH_OS_NAME"
exit 1
fi
echo "====== Setup variables ======"
if [[ "$OPERATING_SYSTEM_NAME" != "osx" ]]; then
echo "Current root directory:"
realpath .
fi
echo "============================="
# ====== OS Variables
if [[ "$OPERATING_SYSTEM_NAME" == "windows" ]]; then
export CMAKE_BUILD_TYPE=MinSizeRel
export BUILD_TYPE=MinSizeRel
VCPKG_DIR="$(realpath .)/vcpkg"
export VCPKG_DIR
export CMAKE_EXTRA_ARGUMENTS="-A x64 -DCMAKE_TOOLCHAIN_FILE:FILEPATH=$VCPKG_DIR/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-windows-static -DOPENSSL_USE_STATIC_LIBS=ON"
export PATH="$PATH:/c/Python3:$PATH:/c/tools/php74:/c/PHP:/c/Program Files (x86)/Microsoft Visual Studio/2019/BuildTools/VC/Tools/MSVC/14.27.29110/bin/Hostx64/x64:/c/Program Files/OpenJDK/openjdk-11.0.8_10/bin:/c/Program Files/CMake/bin:/c/ProgramData/chocolatey/bin:/c/Program Files/apache-maven-3.6.3/bin:/c/ProgramData/chocolatey/lib/maven/apache-maven-3.6.3/bin:/c/ProgramData/chocolatey/lib/base64/tools:/c/Program Files/NASM"
export CPU_CORES=" -- -m"
elif [[ "$OPERATING_SYSTEM_NAME" == "osx" ]]; then
export BUILD_TYPE=MinSizeRel
export CMAKE_EXTRA_ARGUMENTS="-DOPENSSL_ROOT_DIR=/usr/local/opt/openssl/"
export CPU_CORES=" -- -j${CPU_CORES_NUM}"
elif [[ "$OPERATING_SYSTEM_NAME" == "linux" ]]; then
export BUILD_TYPE=MinSizeRel
export CPU_CORES=" -- -j${CPU_CORES_NUM}"
fi
cd ./scripts/core/
source ./setup-variables.sh
cd ../../
# ====== Print variables
echo "REVISION=${REVISION}"
echo "BUILD_TYPE=${BUILD_TYPE}"
echo "TD_SRC_DIR=${TD_SRC_DIR}"
echo "TD_BIN_DIR=${TD_BIN_DIR}"
echo "TDNATIVES_BIN_DIR=${TDNATIVES_BIN_DIR}"
echo "TDNATIVES_CPP_SRC_DIR=${TDNATIVES_CPP_SRC_DIR}"
echo "TDNATIVES_DOCS_BIN_DIR=${TDNATIVES_DOCS_BIN_DIR}"
echo "TD_BUILD_DIR=${TD_BUILD_DIR}"
echo "TDNATIVES_CPP_BUILD_DIR=${TDNATIVES_CPP_BUILD_DIR}"
echo "JAVA_SRC_DIR=${JAVA_SRC_DIR}"
echo "TDLIB_SERIALIZER_DIR=${TDLIB_SERIALIZER_DIR}"
echo "PATH=${PATH}"
echo "JAVA_HOME=${JAVA_HOME}"
echo "JAVA_INCLUDE_PATH=${JAVA_INCLUDE_PATH}"
echo "CMAKE_EXTRA_ARGUMENTS=${CMAKE_EXTRA_ARGUMENTS}"
echo "VCPKG_DIR=${VCPKG_DIR}"
echo "MAVEN_OPTS=${MAVEN_OPTS}"
echo "GH_CPU_ARCH=${GH_CPU_ARCH}"
echo "CPU_ARCHITECTURE_NAME=${CPU_ARCHITECTURE_NAME}"
echo "CPU_CORES_NUM=${CPU_CORES_NUM}"
echo "CPU_CORES=${CPU_CORES}"
echo "GH_OS_NAME=${GH_OS_NAME}"
echo "GH_MATRIX_ARCH=${GH_MATRIX_ARCH}"
echo "OPERATING_SYSTEM_NAME=${OPERATING_SYSTEM_NAME}"
echo "OPERATING_SYSTEM_NAME_SHORT=${OPERATING_SYSTEM_NAME_SHORT}"
echo "SRC_TDJNI_LIBNAME=${SRC_TDJNI_LIBNAME}"
echo "DEST_TDJNI_LIBNAME=${DEST_TDJNI_LIBNAME}"

8
scripts/core/build_generated_maven_project.sh
View File

@ -1,8 +0,0 @@
#!/bin/bash -e
cd ../../generated
[ -f ./src/main/java/it/tdlight/jni/TdApi.java ] && rm ./src/main/java/it/tdlight/jni/TdApi.java
mvn -B clean install
echo "Done."
exit 0

21
scripts/core/build_generated_tdapi_maven_project.sh
View File

@ -1,21 +0,0 @@
#!/bin/bash -e
# MAIN REQUIRED ENVIRONMENT VARIABLES:
# API_TYPE = <legacy | sealed>
# Check variables correctness
if [ -z "${API_TYPE}" ]; then
echo "Missing parameter: API_TYPE"
exit 1
fi
# Print details
echo "Building TdApi package..."
echo "Current directory: $(pwd)"
echo "API type: ${API_TYPE}"
cd ../../generated-"$API_TYPE"
mvn -B "-D${API_TYPE}" clean install
echo "Done."
exit 0

8
scripts/core/clean-all.sh
View File

@ -1,8 +0,0 @@
#!/bin/bash -e
cd ../../
rm -r generated
echo "Done."
exit 0

63
scripts/core/compile_td.sh
View File

@ -1,63 +0,0 @@
#!/bin/bash -e
# MAIN REQUIRED ENVIRONMENT VARIABLES:
# OPERATING_SYSTEM_NAME = <windows | linux | osx>
# CPU_ARCHITECTURE_NAME = <amd64 | aarch64 | 386 | s390x | armhf | ppc64le>
# IMPLEMENTATION_NAME = <tdlib | tdlight>
# BUILD_TYPE = <Debug | Release | RelWithDebInfo | MinSizeRel>
# CPU_CORES = "-- -j<cores>" or "-m" on Windows
# OTHER REQUIRED ENVIRONMENT VARIABLES:
# CMAKE_EXTRA_ARGUMENTS = <args>
# Check variables correctness
if [ -z "${OPERATING_SYSTEM_NAME}" ]; then
echo "Missing parameter: OPERATING_SYSTEM_NAME"
exit 1
fi
if [ -z "${CPU_ARCHITECTURE_NAME}" ]; then
echo "Missing parameter: CPU_ARCHITECTURE_NAME"
exit 1
fi
if [ -z "${IMPLEMENTATION_NAME}" ]; then
echo "Missing parameter: IMPLEMENTATION_NAME"
exit 1
fi
if [ -z "${BUILD_TYPE}" ]; then
echo "Missing parameter: BUILD_TYPE"
exit 1
fi
if [ -z "${CPU_CORES}" ]; then
echo "Missing parameter: CPU_CORES"
exit 1
fi
source ./setup-variables.sh
cd ../../
# Print details
echo "Compiling td..."
echo "Current directory: $(pwd)"
echo "Operating system: ${OPERATING_SYSTEM_NAME}"
echo "Architecture: ${CPU_ARCHITECTURE_NAME}"
echo "Td implementation: ${IMPLEMENTATION_NAME}"
echo "Build type: ${BUILD_TYPE}"
echo "CPU cores count: ${CPU_CORES}"
echo "CMake extra arguments: '${CMAKE_EXTRA_ARGUMENTS}'"
# Delete old data
echo "Deleting old data..."
[ -d ./generated/td_bin/ ] && rm -r ./generated/td_bin/
# Create missing folders
echo "Creating missing folders..."
[ -d ./generated/td_bin/ ] || mkdir ./generated/td_bin/
# Build
echo "Compiling ${IMPLEMENTATION_NAME} td..."
cd ./generated/td_build/
cmake --build . --target install --config "${BUILD_TYPE}" ${CPU_CORES}
echo "Done."
exit 0

132
scripts/core/compile_tdjni.sh
View File

@ -1,132 +0,0 @@
#!/bin/bash -e
# MAIN REQUIRED ENVIRONMENT VARIABLES:
# OPERATING_SYSTEM_NAME = <windows | linux | osx>
# OPERATING_SYSTEM_NAME_SHORT = <win | linux | osx>
# CPU_ARCHITECTURE_NAME = <amd64 | aarch64 | 386 | s390x | armhf | ppc64le>
# IMPLEMENTATION_NAME = <tdlib | tdlight>
# BUILD_TYPE = <Debug | Release | RelWithDebInfo | MinSizeRel>
# CPU_CORES = "-- -j<cores>" or "-m" on Windows
# OTHER REQUIRED ENVIRONMENT VARIABLES:
# CMAKE_EXTRA_ARGUMENTS = <args>
# OPTIONAL ENVIRONMENT VARIABLES:
# CROSS_BUILD_DEPS_DIR = <args>
# Check variables correctness
if [ -z "${OPERATING_SYSTEM_NAME}" ]; then
echo "Missing parameter: OPERATING_SYSTEM_NAME"
exit 1
fi
if [ -z "${OPERATING_SYSTEM_NAME_SHORT}" ]; then
echo "Missing parameter: OPERATING_SYSTEM_NAME_SHORT"
exit 1
fi
if [ -z "${CPU_ARCHITECTURE_NAME}" ]; then
echo "Missing parameter: CPU_ARCHITECTURE_NAME"
exit 1
fi
if [ -z "${IMPLEMENTATION_NAME}" ]; then
echo "Missing parameter: IMPLEMENTATION_NAME"
exit 1
fi
if [ -z "${BUILD_TYPE}" ]; then
echo "Missing parameter: BUILD_TYPE"
exit 1
fi
if [ -z "${CPU_CORES}" ]; then
echo "Missing parameter: CPU_CORES"
exit 1
fi
source ./setup-variables.sh
cd ../../
JAVA_API_PACKAGE_PATH="it/tdlight/jni"
JAVA_LIB_PACKAGE_PATH="it/tdlight/tdnative"
# Print details
echo "Compiling tdjni..."
echo "Current directory: $(pwd)"
echo "Operating system: ${OPERATING_SYSTEM_NAME}"
echo "Architecture: ${CPU_ARCHITECTURE_NAME}"
echo "Td implementation: ${IMPLEMENTATION_NAME}"
echo "Build type: ${BUILD_TYPE}"
echo "CPU cores count: ${CPU_CORES}"
echo "CMake extra arguments: '${CMAKE_EXTRA_ARGUMENTS}'"
echo "JAVA_API_PACKAGE_PATH: '${JAVA_API_PACKAGE_PATH}'"
echo "JAVA_LIB_PACKAGE_PATH: '${JAVA_LIB_PACKAGE_PATH}'"
# Delete old data
echo "Deleting old data..."
[ -d ./generated/tdjni_build/ ] && rm -r ./generated/tdjni_build/
[ -d ./generated/tdjni_bin/ ] && rm -r ./generated/tdjni_bin/
[ -d ./generated/tdjni_docs/ ] && rm -r ./generated/tdjni_docs/
[ -d ./generated/src/main/jni-cpp-src/ ] && rm -r ./generated/src/main/jni-cpp-src/
[ -d ./generated/src/main/jni-java-src/ ] && rm -r ./generated/src/main/jni-java-src/
# Create missing folders
echo "Creating missing folders..."
[ -d ./generated/tdjni_build/ ] || mkdir ./generated/tdjni_build/
[ -d ./generated/tdjni_bin/ ] || mkdir ./generated/tdjni_bin/
[ -d ./generated/tdjni_docs/ ] || mkdir ./generated/tdjni_docs/
# Copy source files
echo "Copying source files..."
cp -r ./src/main/jni-cpp-src/common/. ./generated/src/main/jni-cpp-src
cp -r ./src/main/jni-cpp-src/${IMPLEMENTATION_NAME}/. ./generated/src/main/jni-cpp-src
cp -r ./src/main/jni-java-src ./generated/src/main/jni-java-src
# Create missing jni-src folders
echo "Creating missing jni-src folders..."
[ -d ./generated/src/main/jni-java-src/${JAVA_API_PACKAGE_PATH} ] || mkdir -p ./generated/src/main/jni-java-src/${JAVA_API_PACKAGE_PATH}
# Copy executables
echo "Copying executables..."
if [[ "$OPERATING_SYSTEM_NAME" == "windows" ]]; then
TD_GENERATED_BINARIES_DIR=$(realpath -m ./generated/td_tools/td/generate/Release)
else
TD_GENERATED_BINARIES_DIR=$(realpath -m ./generated/td_tools/td/generate)
fi
export TD_GENERATED_BINARIES_DIR
# Configure cmake
echo "Configuring CMake..."
cd ./generated/tdjni_build/
CMAKE_EXTRA_ARGUMENTS_TDJNI=""
if [[ -n "$CROSS_BUILD_DEPS_DIR" ]]; then
# shellcheck disable=SC2089
CMAKE_EXTRA_ARGUMENTS_TDJNI="${CMAKE_EXTRA_ARGUMENTS_TDJNI} -DCMAKE_TOOLCHAIN_FILE=${CROSS_BUILD_DEPS_DIR}/toolchain.cmake"
fi
# shellcheck disable=SC2086
cmake \
"-DCMAKE_BUILD_TYPE=${BUILD_TYPE}" \
-DTD_GENERATED_BINARIES_DIR=${TD_GENERATED_BINARIES_DIR} \
"-DTD_SRC_DIR=$(realpath -m ../implementation/)" \
"-DTDNATIVES_BIN_DIR=$(realpath -m ../tdjni_bin/)" \
"-DTDNATIVES_DOCS_BIN_DIR=$(realpath -m ../tdjni_docs/)" \
"-DTd_DIR=$(realpath -m ../td_bin/lib/cmake/Td/)" \
"-DJAVA_SRC_DIR=$(realpath -m ../src/main/jni-java-src/)" \
"-DTDNATIVES_CPP_SRC_DIR:PATH=$(realpath -m ../src/main/jni-cpp-src/)" \
${CMAKE_EXTRA_ARGUMENTS_TDJNI} \
${CMAKE_EXTRA_ARGUMENTS} \
"$(realpath -m ../src/main/jni-cpp-src/)"
# Build
echo "Compiling ${IMPLEMENTATION_NAME} jni..."
cmake --build . --target install --config "${BUILD_TYPE}" ${CPU_CORES}
cd ..
# Copy to resources
echo "Copying to resources..."
[ -d ./src/main/resources/META-INF/tdlightjni/ ] || mkdir -p ./src/main/resources/META-INF/tdlightjni/
if [[ "$OPERATING_SYSTEM_NAME" == "windows" ]]; then
cp ./tdjni_bin/tdjni.dll ./src/main/resources/META-INF/tdlightjni/tdjni-${OPERATING_SYSTEM_NAME_SHORT}-${CPU_ARCHITECTURE_NAME}.dll
elif [[ "$OPERATING_SYSTEM_NAME" == "osx" ]]; then
cp ./tdjni_bin/libtdjni.dylib ./src/main/resources/META-INF/tdlightjni/tdjni-${OPERATING_SYSTEM_NAME_SHORT}-${CPU_ARCHITECTURE_NAME}.dylib
elif [[ "$OPERATING_SYSTEM_NAME" == "linux" ]]; then
cp ./tdjni_bin/libtdjni.so ./src/main/resources/META-INF/tdlightjni/tdjni-${OPERATING_SYSTEM_NAME_SHORT}-${CPU_ARCHITECTURE_NAME}.so
fi
echo "Done."
exit 0

87
scripts/core/configure_td.sh
View File

@ -1,87 +0,0 @@
#!/bin/bash -e
# MAIN REQUIRED ENVIRONMENT VARIABLES:
# OPERATING_SYSTEM_NAME = <windows | linux | osx>
# CPU_ARCHITECTURE_NAME = <amd64 | aarch64 | 386 | s390x | armhf | ppc64le>
# IMPLEMENTATION_NAME = <tdlib | tdlight>
# BUILD_TYPE = <Debug | Release | RelWithDebInfo | MinSizeRel>
# CPU_CORES = "-- -j<cores>" or "-m" on Windows
# OTHER REQUIRED ENVIRONMENT VARIABLES:
# CMAKE_EXTRA_ARGUMENTS = <args>
# Check variables correctness
if [ -z "${OPERATING_SYSTEM_NAME}" ]; then
echo "Missing parameter: OPERATING_SYSTEM_NAME"
exit 1
fi
if [ -z "${CPU_ARCHITECTURE_NAME}" ]; then
echo "Missing parameter: CPU_ARCHITECTURE_NAME"
exit 1
fi
if [ -z "${IMPLEMENTATION_NAME}" ]; then
echo "Missing parameter: IMPLEMENTATION_NAME"
exit 1
fi
if [ -z "${BUILD_TYPE}" ]; then
echo "Missing parameter: BUILD_TYPE"
exit 1
fi
if [ -z "${CPU_CORES}" ]; then
echo "Missing parameter: CPU_CORES"
exit 1
fi
source ./setup-variables.sh
cd ../../
# Print details
echo "Configuring td..."
echo "Current directory: $(pwd)"
echo "Operating system: ${OPERATING_SYSTEM_NAME}"
echo "Architecture: ${CPU_ARCHITECTURE_NAME}"
echo "Td implementation: ${IMPLEMENTATION_NAME}"
echo "Build type: ${BUILD_TYPE}"
echo "CPU cores count: ${CPU_CORES}"
echo "CMake extra arguments: '${CMAKE_EXTRA_ARGUMENTS}'"
# Delete old data
echo "Deleting old data..."
[ -d ./generated/td_build/ ] && rm -r ./generated/td_build/
# Create missing folders
echo "Creating missing folders..."
[ -d ./generated/td_build/ ] || mkdir ./generated/td_build/
# Configure cmake
echo "Configuring CMake..."
cd ./generated/td_build/
if [[ "$IMPLEMENTATION_NAME" = "tdlight" ]]; then
CMAKE_EXTRA_ARGUMENTS_TD="-DTD_SKIP_BENCHMARK=ON -DTD_SKIP_TEST=ON -DTD_SKIP_TG_CLI=ON"
else
CMAKE_EXTRA_ARGUMENTS_TD=""
fi
if [[ "$OPERATING_SYSTEM_NAME" == "linux" ]]; then
CMAKE_EXTRA_ARGUMENTS_TD="${CMAKE_EXTRA_ARGUMENTS_TD} -DTD_ENABLE_LTO=ON"
fi
if [[ -n "$CROSS_BUILD_DEPS_DIR" ]]; then
# shellcheck disable=SC2089
CMAKE_EXTRA_ARGUMENTS_TD="${CMAKE_EXTRA_ARGUMENTS_TD} -DCMAKE_TOOLCHAIN_FILE=${CROSS_BUILD_DEPS_DIR}/toolchain.cmake"
fi
export CMAKE_EXTRA_ARGUMENTS_TD
INSTALL_PREFIX="$(realpath -m ../td_bin/)"
INSTALL_BINDIR="$(realpath -m ../td_bin/bin)"
echo "Install prefix: $INSTALL_PREFIX"
echo "Install bindir: $INSTALL_BINDIR"
# shellcheck disable=SC2086
cmake "-DCMAKE_BUILD_TYPE=${BUILD_TYPE}" \
-DCMAKE_INSTALL_PREFIX:PATH="$INSTALL_PREFIX" \
-DCMAKE_INSTALL_BINDIR:PATH="$INSTALL_BINDIR" \
-DTD_ENABLE_JNI=ON \
${CMAKE_EXTRA_ARGUMENTS_TD} \
${CMAKE_EXTRA_ARGUMENTS} \
../implementation
echo "Done."
exit 0

34
scripts/core/deploy_release.sh
View File

@ -1,34 +0,0 @@
#!/bin/bash -e
# OTHER REQUIRED ENVIRONMENT VARIABLES:
# REVISION = <revision>
# OTHER ENVIRONMENT VARIABLES:
# API_TYPE = <legacy|sealed>
# SSL_TYPE = <ssl1|ssl3>
# Check variables correctness
if [ -z "${REVISION}" ]; then
echo "Missing parameter: REVISION"
exit 1
fi
source ./setup-variables.sh
FALLBACK_API_TYPE="sealed"
FALLBACK_SSL_TYPE="ssl1"
SAFE_VERSION_NAME="v4_0_${REVISION}"
REVISION_SUFFIX=""
USE_SSL3="False"
if [ "${SSL_TYPE:-${FALLBACK_SSL_TYPE}}" != "ssl1" ]; then
USE_SSL3="True"
fi
REVISION_MVN="4.0.${REVISION}${REVISION_SUFFIX}"
if [ -z "${API_TYPE}" ]; then
cd ../../generated
else
cd "../../generated-${API_TYPE}"
fi
mvn -B -Drevision="${REVISION_MVN}" -DsafeVersionName="${SAFE_VERSION_NAME}" -Dssl3=${USE_SSL3} "-D${API_TYPE:-${FALLBACK_API_TYPE}}" deploy
echo "Done."
exit 0

25
scripts/core/deploy_snapshot.sh
View File

@ -1,25 +0,0 @@
#!/bin/bash -e
# OTHER ENVIRONMENT VARIABLES:
# API_TYPE = <legacy|sealed>
# SSL_TYPE = <ssl1|ssl3>
if [ -z "${API_TYPE}" ]; then
cd ../../generated
else
cd "../../generated-${API_TYPE}"
fi
FALLBACK_API_TYPE="sealed"
FALLBACK_SSL_TYPE="ssl1"
SAFE_VERSION_NAME="v4_0_0"
REVISION_SUFFIX="-SNAPSHOT"
USE_SSL3="False"
if [ "${SSL_TYPE:-${FALLBACK_SSL_TYPE}}" != "ssl1" ]; then
USE_SSL3="True"
fi
REVISION_MVN="4.0.0${REVISION_SUFFIX}"
mvn -B -Drevision="${REVISION_MVN}" -DsafeVersionName="${SAFE_VERSION_NAME}" -Dssl3=${USE_SSL3} "-D${API_TYPE:-${FALLBACK_API_TYPE}}" deploy
echo "Done."
exit 0

54
scripts/core/generate_maven_project.sh
View File

@ -1,54 +0,0 @@
#!/bin/bash -e
# MAIN REQUIRED ENVIRONMENT VARIABLES:
# OPERATING_SYSTEM_NAME = <windows | linux | osx>
# CPU_ARCHITECTURE_NAME = <amd64 | aarch64 | 386 | s390x | armhf | ppc64le>
# IMPLEMENTATION_NAME = <tdlib | tdlight>
# Check variables correctness
if [ -z "${OPERATING_SYSTEM_NAME}" ]; then
echo "Missing parameter: OPERATING_SYSTEM_NAME"
exit 1
fi
if [ -z "${CPU_ARCHITECTURE_NAME}" ]; then
echo "Missing parameter: CPU_ARCHITECTURE_NAME"
exit 1
fi
if [ -z "${IMPLEMENTATION_NAME}" ]; then
echo "Missing parameter: IMPLEMENTATION_NAME"
exit 1
fi
source ./setup-variables.sh
cd ../../
# Print details
echo "Generating maven project..."
echo "Current directory: $(pwd)"
echo "Operating system: ${OPERATING_SYSTEM_NAME}"
echo "Architecture: ${CPU_ARCHITECTURE_NAME}"
echo "Td implementation: ${IMPLEMENTATION_NAME}"
# Delete old data
echo "Deleting old data..."
[ -d ./generated/ ] && rm -r ./generated/
# Create missing folders
echo "Creating missing folders..."
[ -d ./generated/ ] || mkdir ./generated/
[ -d ./src/main/java/ ] || mkdir -p ./src/main/java/
[ -d ./src/main/resources/ ] || mkdir -p ./src/main/resources/
[ -d ./generated/src/main/ ] || mkdir -p ./generated/src/main/
[ -d ./generated/src/main/ ] || mkdir -p ./generated/src/main/
# Generate pom.xml
echo "Generating pom.xml..."
sed -f "src/main/replacements/replace-${OPERATING_SYSTEM_NAME}-${CPU_ARCHITECTURE_NAME}-${IMPLEMENTATION_NAME}-sealed.sed" src/main/jni-project-src/pom.template.xml > generated/pom.xml
# Copy source files
echo "Copying source files..."
cp -r ./src/main/java ./generated/src/main/java
cp -r ./src/main/resources ./generated/src/main/resources
echo "Done."
exit 0

106
scripts/core/generate_td_tools.sh
View File

@ -1,106 +0,0 @@
#!/bin/bash -e
# MAIN REQUIRED ENVIRONMENT VARIABLES:
# OPERATING_SYSTEM_NAME = <windows | linux | osx>
# CPU_ARCHITECTURE_NAME = <amd64 | aarch64 | 386 | s390x | armhf | ppc64le>
# IMPLEMENTATION_NAME = <tdlib | tdlight>
# CPU_CORES = "-- -j<cores>" or "-m" on Windows
# OTHER REQUIRED ENVIRONMENT VARIABLES:
# CMAKE_EXTRA_ARGUMENTS = <args>
# Check variables correctness
if [ -z "${OPERATING_SYSTEM_NAME}" ]; then
echo "Missing parameter: OPERATING_SYSTEM_NAME"
exit 1
fi
if [ -z "${CPU_ARCHITECTURE_NAME}" ]; then
echo "Missing parameter: CPU_ARCHITECTURE_NAME"
exit 1
fi
if [ -z "${IMPLEMENTATION_NAME}" ]; then
echo "Missing parameter: IMPLEMENTATION_NAME"
exit 1
fi
if [ -z "${CPU_CORES}" ]; then
echo "Missing parameter: CPU_CORES"
exit 1
fi
source ./setup-variables.sh
cd ../../
# Print details
echo "Generating td tools..."
echo "Current directory: $(pwd)"
echo "Operating system: ${OPERATING_SYSTEM_NAME}"
echo "Architecture: ${CPU_ARCHITECTURE_NAME}"
echo "Td implementation: ${IMPLEMENTATION_NAME}"
echo "CPU cores count: ${CPU_CORES}"
echo "CMake extra arguments: '${CMAKE_EXTRA_ARGUMENTS}'"
# Delete old data
echo "Deleting old data..."
[ -d ./generated/implementation/ ] && rm -r ./generated/implementation/
[ -d ./generated/td_tools/ ] && rm -r ./generated/td_tools/
# Create missing folders
echo "Creating missing folders..."
[ -d "./generated" ] || mkdir "./generated"
# Copy implementation files
echo "Copying implementation files..."
cp -r implementations/${IMPLEMENTATION_NAME} ./generated/implementation
# Patch implementation files (sed replacements)
echo "Patching implementation files using sed replacements..."
#Fix bug: https://github.com/tdlib/td/issues/1238
if [[ "$IMPLEMENTATION_NAME" = "tdlib" ]]; then
if [[ "$OPERATING_SYSTEM_NAME" = "osx" ]]; then
sed -f "src/main/replacements/fix-tdlib-tdutils-windows-cmake.sed" -i "" ./generated/implementation/tdutils/CMakeLists.txt
else
sed -f "src/main/replacements/fix-tdlib-tdutils-windows-cmake.sed" -i"" ./generated/implementation/tdutils/CMakeLists.txt
fi
fi
# Patch implementation files (git patches)
echo "Patching implementation files using git patches..."
if [[ "$IMPLEMENTATION_NAME" = "tdlib" ]]; then
if [[ -d "src/main/patches/tdlib" && "$(ls -A src/main/patches/tdlib)" ]]; then
git apply --directory="generated/implementation" src/main/patches/tdlib/*.patch
fi
fi
if [[ "$IMPLEMENTATION_NAME" = "tdlight" ]]; then
if [[ -d "src/main/patches/tdlight" && "$(ls -A src/main/patches/tdlight)" ]]; then
git apply --directory="generated/implementation" src/main/patches/tdlight/*.patch
fi
fi
# Configure cmake
echo "Configuring CMake..."
mkdir ./generated/td_tools/
cd ./generated/td_tools/
cmake -DCMAKE_BUILD_TYPE=Release -DTD_ENABLE_JNI=ON ${CMAKE_EXTRA_ARGUMENTS} ../implementation/
# Run cmake to generate common tools
echo "Generating cross compilation tools..."
cmake --build . --target prepare_cross_compiling --config Release ${CPU_CORES}
# Run cmake to generate java tools
echo "Generating java tools..."
cmake --build . --target td_generate_java_api --config Release ${CPU_CORES}
# Copy tlo files
echo "Copying *.tlo files..."
cp -r ../implementation/td/generate/auto/tlo/. ../implementation/td/generate/scheme/.
echo "Generated executable '$(realpath -m ./td/generate/generate_common)'"
echo "Generated executable '$(realpath -m ./td/generate/td_generate_java_api)'"
echo "Generated executable '$(realpath -m ./td/generate/td_generate_json)'"
echo "Generated executable '$(realpath -m ../implementation/td/generate/JavadocTlDocumentationGenerator.php)'"
echo "Generated executable '$(realpath -m ../implementation/td/generate/TlDocumentationGenerator.php)'"
echo "Generated executable '$(realpath -m ../implementation/td/generate/scheme/td_api.tl)'"
echo "Generated executable '$(realpath -m ../implementation/td/generate/scheme/td_api.tlo)'"
echo "Done."
exit 0

120
scripts/core/generate_tdapi_java_file.sh
View File

@ -1,120 +0,0 @@
#!/bin/bash -e
# MAIN REQUIRED ENVIRONMENT VARIABLES:
# OPERATING_SYSTEM_NAME = <windows | linux | osx>
# CPU_ARCHITECTURE_NAME = <amd64 | aarch64 | 386 | s390x | armhf | ppc64le>
# IMPLEMENTATION_NAME = <tdlib | tdlight>
# API_TYPE = <legacy | sealed>
# CPU_CORES = "-- -j<cores>" or "-m" on Windows
# OTHER REQUIRED ENVIRONMENT VARIABLES:
# CMAKE_EXTRA_ARGUMENTS = <args>
# Check variables correctness
if [ -z "${OPERATING_SYSTEM_NAME}" ]; then
echo "Missing parameter: OPERATING_SYSTEM_NAME"
exit 1
fi
if [ -z "${CPU_ARCHITECTURE_NAME}" ]; then
echo "Missing parameter: CPU_ARCHITECTURE_NAME"
exit 1
fi
if [ -z "${IMPLEMENTATION_NAME}" ]; then
echo "Missing parameter: IMPLEMENTATION_NAME"
exit 1
fi
if [ -z "${API_TYPE}" ]; then
echo "Missing parameter: API_TYPE"
exit 1
fi
if [ -z "${CPU_CORES}" ]; then
echo "Missing parameter: CPU_CORES"
exit 1
fi
source ./setup-variables.sh
if [[ "$API_TYPE" == "sealed" ]]; then
MIN_JDK_VERSION="17"
SEALED="true"
else
MIN_JDK_VERSION="8"
SEALED="false"
fi
cd ../../
JAVA_API_PACKAGE_PATH="it/tdlight/jni"
JAVA_LIB_PACKAGE_PATH="it/tdlight/tdnative"
# Print details
echo "Generating TdApi.java..."
echo "Current directory: $(pwd)"
echo "Operating system: ${OPERATING_SYSTEM_NAME}"
echo "Architecture: ${CPU_ARCHITECTURE_NAME}"
echo "Td implementation: ${IMPLEMENTATION_NAME}"
echo "API type: ${API_TYPE}"
echo "Min jdk version: ${MIN_JDK_VERSION}"
echo "Sealed: ${SEALED}"
echo "CPU cores count: ${CPU_CORES}"
echo "CMake extra arguments: '${CMAKE_EXTRA_ARGUMENTS}'"
echo "JAVA_API_PACKAGE_PATH: '${JAVA_API_PACKAGE_PATH}'"
echo "JAVA_LIB_PACKAGE_PATH: '${JAVA_LIB_PACKAGE_PATH}'"
# Setup constants
if [[ "$OPERATING_SYSTEM_NAME" == "windows" ]]; then
export PYTHON_EXECUTABLE="python"
else
export PYTHON_EXECUTABLE="python3"
fi
# Delete old data
echo "Deleting old data..."
[ -d ./generated-"$API_TYPE"/tdjni_build/ ] && rm -r ./generated-"$API_TYPE"/tdjni_build/
[ -d ./generated-"$API_TYPE"/tdjni_bin/ ] && rm -r ./generated-"$API_TYPE"/tdjni_bin/
[ -d ./generated-"$API_TYPE"/tdjni_docs/ ] && rm -r ./generated-"$API_TYPE"/tdjni_docs/
[ -f ./generated-"$API_TYPE"/src/main/java17/${JAVA_API_PACKAGE_PATH}/TdApi.java ] && rm ./generated-"$API_TYPE"/src/main/java17/${JAVA_API_PACKAGE_PATH}/TdApi.java
[ -f ./generated-"$API_TYPE"/src/main/java/${JAVA_API_PACKAGE_PATH}/TdApi.java ] && rm ./generated-"$API_TYPE"/src/main/java/${JAVA_API_PACKAGE_PATH}/TdApi.java
# Create missing folders
echo "Creating missing folders..."
[ -d "./generated-$API_TYPE/src/main/java/${JAVA_API_PACKAGE_PATH}/" ] || mkdir -p "./generated-$API_TYPE/src/main/java/${JAVA_API_PACKAGE_PATH}/"
[ -d "./generated-$API_TYPE/src/main/java/${JAVA_LIB_PACKAGE_PATH}/" ] || mkdir -p "./generated-$API_TYPE/src/main/java/${JAVA_LIB_PACKAGE_PATH}/"
[ -d ./generated-"$API_TYPE"/tdjni_build/ ] || mkdir ./generated-"$API_TYPE"/tdjni_build/
[ -d ./generated-"$API_TYPE"/tdjni_bin/ ] || mkdir ./generated-"$API_TYPE"/tdjni_bin/
[ -d ./generated-"$API_TYPE"/tdjni_docs/ ] || mkdir ./generated-"$API_TYPE"/tdjni_docs/
# Copy executables
echo "Copying executables..."
if [[ "$OPERATING_SYSTEM_NAME" == "windows" ]]; then
TD_GENERATED_BINARIES_DIR="$(realpath -m ./generated/td_tools/td/generate/Release)"
else
TD_GENERATED_BINARIES_DIR="$(realpath -m ./generated/td_tools/td/generate)"
fi
export TD_GENERATED_BINARIES_DIR
# Configure cmake
echo "Configuring CMake..."
cd ./generated/
echo "Telegram source path: '$(realpath -m ./implementation/)'"
# Run cmake to generate TdApi.java
echo "Generating TdApi.java..."
./td_tools/td/generate/td_generate_java_api TdApi "./implementation/td/generate/scheme/td_api.tlo" "../generated-$API_TYPE/src/main/java" "$JAVA_API_PACKAGE_PATH"
php ./implementation/td/generate/JavadocTlDocumentationGenerator.php "./implementation/td/generate/scheme/td_api.tl" "../generated-$API_TYPE/src/main/java/${JAVA_API_PACKAGE_PATH}/TdApi.java"
mv "../generated-$API_TYPE/src/main/java/${JAVA_API_PACKAGE_PATH}/TdApi.java" "../generated-$API_TYPE/src/main/java/${JAVA_API_PACKAGE_PATH}/php_TdApi.java"
echo "Patching TdApi.java for Java ${MIN_JDK_VERSION}..."
${PYTHON_EXECUTABLE} ../scripts/core/tdlib-serializer "$(realpath -m ../generated-"$API_TYPE"/src/main/java/${JAVA_API_PACKAGE_PATH}/php_TdApi.java)" "$(realpath -m ../generated-"$API_TYPE"/src/main/java/${JAVA_API_PACKAGE_PATH}/unexpanded_TdApi.java)" "$(realpath -m ../scripts/core/tdlib-serializer/headers.txt)" "$SEALED"
if [[ "$OPERATING_SYSTEM_NAME" == "osx" ]]; then
unexpand --tabs=2 ../generated-"$API_TYPE"/src/main/java/${JAVA_API_PACKAGE_PATH}/unexpanded_TdApi.java > ../generated-"$API_TYPE"/src/main/java/${JAVA_API_PACKAGE_PATH}/TdApi.java
else
unexpand -t 2 ../generated-"$API_TYPE"/src/main/java/${JAVA_API_PACKAGE_PATH}/unexpanded_TdApi.java > ../generated-"$API_TYPE"/src/main/java/${JAVA_API_PACKAGE_PATH}/TdApi.java
fi
rm ../generated-"$API_TYPE"/src/main/java/${JAVA_API_PACKAGE_PATH}/unexpanded_TdApi.java
echo "Generated '$(realpath -m ../generated-"$API_TYPE"/src/main/java/${JAVA_API_PACKAGE_PATH}/TdApi.java)'"
rm ../generated-"$API_TYPE"/src/main/java/${JAVA_API_PACKAGE_PATH}/php_TdApi.java
echo "Done."
exit 0

57
scripts/core/generate_tdapi_maven_project.sh
View File

@ -1,57 +0,0 @@
#!/bin/bash -e
# MAIN REQUIRED ENVIRONMENT VARIABLES:
# OPERATING_SYSTEM_NAME = <windows | linux | osx>
# CPU_ARCHITECTURE_NAME = <amd64 | aarch64 | 386 | s390x | armhf | ppc64le>
# IMPLEMENTATION_NAME = <tdlib | tdlight>
# API_TYPE = <legacy | sealed>
# Check variables correctness
if [ -z "${OPERATING_SYSTEM_NAME}" ]; then
echo "Missing parameter: OPERATING_SYSTEM_NAME"
exit 1
fi
if [ -z "${CPU_ARCHITECTURE_NAME}" ]; then
echo "Missing parameter: CPU_ARCHITECTURE_NAME"
exit 1
fi
if [ -z "${IMPLEMENTATION_NAME}" ]; then
echo "Missing parameter: IMPLEMENTATION_NAME"
exit 1
fi
if [ -z "${API_TYPE}" ]; then
echo "Missing parameter: API_TYPE"
exit 1
fi
source ./setup-variables.sh
cd ../../
# Print details
echo "Generating maven project..."
echo "Current directory: $(pwd)"
echo "Operating system: ${OPERATING_SYSTEM_NAME}"
echo "Architecture: ${CPU_ARCHITECTURE_NAME}"
echo "Td implementation: ${IMPLEMENTATION_NAME}"
echo "API type: ${API_TYPE}"
# Delete old data
echo "Deleting old data..."
[ -d "./generated-${API_TYPE}" ] && rm -r "./generated-${API_TYPE}"
# Create missing folders
echo "Creating missing folders..."
[ -d "./generated-${API_TYPE}" ] || mkdir "./generated-${API_TYPE}"
[ -d "./generated-${API_TYPE}/src/main" ] || mkdir -p "./generated-${API_TYPE}/src/main"
# Generate pom.xml
echo "Generating pom.xml..."
sed -f "src/main/replacements/replace-${OPERATING_SYSTEM_NAME}-${CPU_ARCHITECTURE_NAME}-${IMPLEMENTATION_NAME}-${API_TYPE}.sed" src/main/tdapi-project-src/pom.template.xml > "./generated-${API_TYPE}/pom.xml"
# Copy source files
echo "Copying source files..."
[ -d ./src/main/tdapi-java ] && cp -r ./src/main/tdapi-java "./generated-${API_TYPE}/src/main/java"
[ -d ./src/main/tdapi-resources ] && cp -r ./src/main/tdapi-resources "./generated-${API_TYPE}/src/main/resources"
echo "Done."
exit 0

119
scripts/core/install-dependencies.sh
View File

@ -1,119 +0,0 @@
#!/bin/bash -e
# MAIN REQUIRED ENVIRONMENT VARIABLES:
# OPERATING_SYSTEM_NAME = <windows | linux | osx>
# CPU_ARCHITECTURE_NAME = <amd64 | aarch64 | 386 | s390x | armhf | ppc64le>
# IMPLEMENTATION_NAME = <tdlib | tdlight>
# BUILD_TYPE = <Debug | Release | RelWithDebInfo | MinSizeRel>
# CPU_CORES = "-- -j<cores>" or "-m" on Windows
# OTHER REQUIRED ENVIRONMENT VARIABLES:
# CMAKE_EXTRA_ARGUMENTS = <args>
# OPTIONAL ENVIRONMENT VARIABLES:
# CROSS_BUILD_DEPS_DIR = <args>
# Check variables correctness
if [ -z "${OPERATING_SYSTEM_NAME}" ]; then
echo "Missing parameter: OPERATING_SYSTEM_NAME"
exit 1
fi
if [ -z "${CPU_ARCHITECTURE_NAME}" ]; then
echo "Missing parameter: CPU_ARCHITECTURE_NAME"
exit 1
fi
if [ -z "${IMPLEMENTATION_NAME}" ]; then
echo "Missing parameter: IMPLEMENTATION_NAME"
exit 1
fi
if [ -z "${BUILD_TYPE}" ]; then
echo "Missing parameter: BUILD_TYPE"
exit 1
fi
if [ -z "${CPU_CORES}" ]; then
echo "Missing parameter: CPU_CORES"
exit 1
fi
source ./setup-variables.sh
cd ../../
ROOT_DIR="$(pwd)"
# Print details
echo "Installing dependencies..."
echo "Current directory: $ROOT_DIR"
echo "Operating system: ${OPERATING_SYSTEM_NAME}"
echo "Architecture: ${CPU_ARCHITECTURE_NAME}"
echo "Td implementation: ${IMPLEMENTATION_NAME}"
echo "Build type: ${BUILD_TYPE}"
echo "CPU cores count: ${CPU_CORES}"
echo "CMake extra arguments: '${CMAKE_EXTRA_ARGUMENTS}'"
echo "Cross build deps dir: '${CROSS_BUILD_DEPS_DIR}'"
if [[ "$OPERATING_SYSTEM_NAME" == "linux" ]]; then
if [ -n "${CROSS_BUILD_DEPS_DIR}" ]; then
CROSS_OPENJDK_PATH=""
fix_jdk_path() {
# Setup OpenJDK path
CROSS_OPENJDK_PATH=$(find "$CROSS_BUILD_DEPS_DIR/usr/lib/jvm/" -maxdepth 1 -type d -iname "java*jdk*" | head -n 1)
echo "Fixed cross openjdk path: '${CROSS_OPENJDK_PATH}'"
}
check_jdk_existance() {
if [[ ! -d "$CROSS_OPENJDK_PATH" ]]; then
echo "Can't find cross OpenJDK at location $CROSS_OPENJDK_PATH"
exit 1
fi
}
fix_jdk_path
check_jdk_existance
# Create toolchain
echo "Creating toolchain file..."
cd "$ROOT_DIR"
{
echo "set(CMAKE_SYSTEM_PROCESSOR ${CPU_ARCH_LINUX})";
echo "set(CMAKE_C_COMPILER ${CROSS_CC})";
echo "set(CMAKE_C_COMPILER_TARGET ${CLANG_TRIPLE})";
echo "set(CMAKE_CXX_COMPILER ${CROSS_CXX})";
echo "set(CMAKE_CXX_COMPILER_TARGET ${CLANG_TRIPLE})";
echo "set(CMAKE_ASM_COMPILER ${CROSS_CXX})";
echo "set(CMAKE_ASM_COMPILER_TARGET ${CLANG_TRIPLE})";
echo "set(CMAKE_LIBRARY_PATH \"$CROSS_BUILD_DEPS_DIR/\")";
echo "include_directories(\"${CROSS_BUILD_DEPS_DIR}/usr/include/${CPU_ARCH_LINUX}-linux-${CPU_COMPILATION_TOOL}/\")";
echo "SET(CMAKE_FIND_ROOT_PATH \"$CROSS_BUILD_DEPS_DIR\" \"$JAVA_HOME\" \"/\" \"$JAVA_HOME/include\")";
echo "include_directories(\"${CROSS_OPENJDK_PATH}/include\")";
echo "include_directories(\"${CROSS_OPENJDK_PATH}/include/linux\")";
echo "SET(JAVA_HOME \"$JAVA_HOME/\")";
echo "SET(JAVA_INCLUDE_PATH \"$JAVA_HOME/include\")";
echo "SET(JAVA_AWT_INCLUDE_PATH \"$JAVA_HOME/include\")";
echo "SET(JAVA_INCLUDE_PATH2 \"$JAVA_HOME/include/linux\")";
echo "SET(JAVA_JVM_LIBRARY \"$CROSS_OPENJDK_PATH/lib/${JAVA_INSTALLATION_TYPE}/libjvm.so\")";
echo "SET(JAVA_AWT_LIBRARY \"$CROSS_OPENJDK_PATH/lib/libawt.so\")";
cat <<EOF
SET(CMAKE_SYSTEM_NAME Linux)
# Use our definitions for compiler tools
SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
# Search for libraries and headers in the target directories only
SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
EOF
if [[ ${CPU_ARCHITECTURE_NAME} == "aarch64" || ${CPU_ARCHITECTURE_NAME} == "armhf" ]]; then
cat <<EOF
set(CMAKE_THREAD_LIBS_INIT "-lpthread")
set(CMAKE_HAVE_THREADS_LIBRARY 1)
set(CMAKE_USE_WIN32_THREADS_INIT 0)
set(CMAKE_USE_PTHREADS_INIT 1)
set(THREADS_PREFER_PTHREAD_FLAG ON)
EOF
fi
} > "$CROSS_BUILD_DEPS_DIR/toolchain.cmake"
fi
fi;
echo "Done."
exit 0

125
scripts/core/setup-variables.sh
View File

@ -1,125 +0,0 @@
#!/bin/bash -e
if [[ "$CORE_VARIABLES_SET" != "YES" ]]; then
echo "====== Setup variables ======"
if [[ "$OPERATING_SYSTEM_NAME" != "osx" ]]; then
echo "Current root directory:"
realpath "."
fi
echo "============================="
# ====== CPU Architecture Variables
if [[ "$CPU_ARCHITECTURE_NAME" == "aarch64" ]]; then
export CPU_ARCH_JAVA="arm64"
export CPU_ARCH_JAVA_INTERNAL="aarch64"
export JAVA_INSTALLATION_TYPE="server"
export CPU_ARCH_DPKG="arm64"
export CPU_ARCH_CMAKE="aarch64"
export CPU_ARCH_LINUX="aarch64"
export CLANG_TRIPLE="aarch64-linux-gnu"
export CPU_COMPILATION_TOOL="gnu"
elif [[ "$CPU_ARCHITECTURE_NAME" == "armhf" ]]; then
export CPU_ARCH_JAVA="armhf"
export CPU_ARCH_JAVA_INTERNAL="arm"
export JAVA_INSTALLATION_TYPE="server"
export CPU_ARCH_DPKG="armhf"
export CPU_ARCH_CMAKE="arm"
export CPU_ARCH_LINUX="arm"
export CLANG_TRIPLE="arm-linux-gnueabihf"
export CPU_COMPILATION_TOOL="gnueabihf"
elif [[ "$CPU_ARCHITECTURE_NAME" == "s390x" ]]; then
export CPU_ARCH_JAVA="s390x"
export CPU_ARCH_JAVA_INTERNAL="s390x"
export JAVA_INSTALLATION_TYPE="server"
export CPU_ARCH_DPKG="s390x"
export CPU_ARCH_CMAKE="s390x"
export CPU_ARCH_LINUX="s390x"
export CLANG_TRIPLE="s390x-linux-gnu"
export CPU_COMPILATION_TOOL="gnu"
elif [[ "$CPU_ARCHITECTURE_NAME" == "386" ]]; then
export CPU_ARCH_JAVA="386"
export CPU_ARCH_JAVA_INTERNAL="i386"
export JAVA_INSTALLATION_TYPE="server"
export CPU_ARCH_DPKG="i386"
export CPU_ARCH_CMAKE="i686"
export CPU_ARCH_LINUX="i386"
export CLANG_TRIPLE="i386-linux-gnu"
export CPU_COMPILATION_TOOL="gnu"
elif [[ "$CPU_ARCHITECTURE_NAME" == "amd64" ]]; then
export CPU_ARCH_JAVA="amd64"
export CPU_ARCH_JAVA_INTERNAL="amd64"
export JAVA_INSTALLATION_TYPE="server"
export CPU_ARCH_DPKG="amd64"
export CPU_ARCH_CMAKE="x86_64"
export CPU_ARCH_LINUX="x86_64"
export CLANG_TRIPLE="x86_64-linux-gnu"
export CPU_COMPILATION_TOOL="gnu"
elif [[ "$CPU_ARCHITECTURE_NAME" == "ppc64le" ]]; then
export CPU_ARCH_JAVA="ppc64le"
export CPU_ARCH_JAVA_INTERNAL="ppc64le"
export JAVA_INSTALLATION_TYPE="server"
export CPU_ARCH_DPKG="ppc64el"
export CPU_ARCH_CMAKE="powerpc64le"
export CPU_ARCH_LINUX="powerpc64le"
export CLANG_TRIPLE="powerpc64-linux-gnu"
export CPU_COMPILATION_TOOL="gnu"
else
echo "Unrecognized cpu arch: $CPU_ARCHITECTURE_NAME"
exit 1
fi
if [ -z "${CPU_CORES_NUM}" ]; then
export CPU_CORES_NUM="4"
fi
if [[ "$OPERATING_SYSTEM_NAME" == "windows" ]]; then
export CMAKE_EXTRA_ARGUMENTS_TDJNI="${CMAKE_EXTRA_ARGUMENTS_TDJNI} -DOPENSSL_USE_STATIC_LIBS=True"
elif [[ "$OPERATING_SYSTEM_NAME" == "osx" ]]; then
export CMAKE_EXTRA_ARGUMENTS_TDJNI="${CMAKE_EXTRA_ARGUMENTS_TDJNI} -DOPENSSL_USE_STATIC_LIBS=True"
elif [[ "$OPERATING_SYSTEM_NAME" == "linux" ]]; then
export CMAKE_EXTRA_ARGUMENTS_TDJNI="${CMAKE_EXTRA_ARGUMENTS_TDJNI} -DTD_ENABLE_LTO=ON"
if [[ "$CPU_ARCHITECTURE_NAME" == "386" ]] || [[ "$CPU_ARCHITECTURE_NAME" == "armhf" ]]; then
export CMAKE_EXE_LINKER_FLAGS="$CMAKE_EXE_LINKER_FLAGS -latomic"
export LDFLAGS="$LDFLAGS -latomic"
export CXXFLAGS="$CXXFLAGS -latomic"
fi
export CXXFLAGS="$CXXFLAGS -static-libgcc -static-libstdc++"
export CC="gcc"
export CXX="g++"
export CROSS_CXXFLAGS="$CXXFLAGS -static-libgcc -static-libstdc++"
if [[ "${CPU_ARCH_CMAKE}" == "x86_64" && "${CPU_COMPILATION_TOOL}" == "gnu" ]]; then
export CROSS_CC="gcc"
export CROSS_CXX="g++"
else
export CROSS_CC="${CPU_ARCH_CMAKE}-linux-${CPU_COMPILATION_TOOL}-gcc"
export CROSS_CXX="${CPU_ARCH_CMAKE}-linux-${CPU_COMPILATION_TOOL}-g++"
fi
fi
export JAVA_TOOL_OPTIONS="-Dfile.encoding=UTF8"
# ====== Print variables
echo "========= Variables ========="
echo "Variables"
echo "JAVA_TOOL_OPTIONS=${JAVA_TOOL_OPTIONS}"
echo "CPU_ARCH_JAVA=${CPU_ARCH_JAVA}"
echo "CPU_ARCH_JAVA_INTERNAL=${CPU_ARCH_JAVA_INTERNAL}"
echo "JAVA_INSTALLATION_TYPE=${JAVA_INSTALLATION_TYPE}"
echo "CPU_ARCH_DPKG=${CPU_ARCH_DPKG}"
echo "CPU_ARCH_CMAKE=${CPU_ARCH_CMAKE}"
echo "CPU_ARCH_LINUX=${CPU_ARCH_LINUX}"
echo "CLANG_TRIPLE=${CLANG_TRIPLE}"
echo "CPU_COMPILATION_TOOL=${CPU_COMPILATION_TOOL}"
echo "CC=${CC}"
echo "CXX=${CXX}"
echo "CFLAGS=${CFLAGS}"
echo "CXXFLAGS=${CXXFLAGS}"
echo "CMAKE_EXE_LINKER_FLAGS=${CMAKE_EXE_LINKER_FLAGS}"
echo "CMAKE_EXTRA_ARGUMENTS=${CMAKE_EXTRA_ARGUMENTS}"
echo "CROSS_BUILD_DEPS_DIR=${CROSS_BUILD_DEPS_DIR}"
echo "============================="
export CORE_VARIABLES_SET="YES"
fi

28
scripts/utils/compile-natives-package.sh
View File

@ -1,28 +0,0 @@
#!/bin/bash -e
# This script compiles tdlight/tdlib jni binaries for your platform.
# Fill the variables with your system details.
#
# MAIN REQUIRED ENVIRONMENT VARIABLES:
# OPERATING_SYSTEM_NAME = <windows | linux | osx>
# CPU_ARCHITECTURE_NAME = <amd64 | aarch64 | 386 | armhf | ppc64le>
# OPERATING_SYSTEM_NAME_SHORT = <win | linux | osx>
# IMPLEMENTATION_NAME = <tdlib | tdlight>
# CPU_CORES = "-- -j<cores>" or "-m" on Windows
# CMAKE_EXTRA_ARGUMENTS = <args>
# REVISION = <revision>
# OPTIONAL ENVIRONMENT VARIABLES:
# CROSS_BUILD_DEPS_DIR = <args>
cd ../core
source ./setup-variables.sh
./install-dependencies.sh
./generate_maven_project.sh
./generate_td_tools.sh
./configure_td.sh
./compile_td.sh
./compile_tdjni.sh
./build_generated_maven_project.sh
echo "Done."
exit 0

33
scripts/utils/compile-tdapi-package.sh
View File

@ -1,33 +0,0 @@
#!/bin/bash -e
# This script compiles tdlight/tdlib api for your platform.
# Fill the variables with your system details.
#
# MAIN REQUIRED ENVIRONMENT VARIABLES:
# OPERATING_SYSTEM_NAME = <windows | linux | osx>
# CPU_ARCHITECTURE_NAME = <amd64 | aarch64 | 386 | armhf | ppc64le>
# OPERATING_SYSTEM_NAME_SHORT = <win | linux | osx>
# IMPLEMENTATION_NAME = <tdlib | tdlight>
# CPU_CORES = "-- -j<cores>" or "-m" on Windows
# CMAKE_EXTRA_ARGUMENTS = <args>
# REVISION = <revision>
# OPTIONAL ENVIRONMENT VARIABLES:
# CROSS_BUILD_DEPS_DIR = <args>
cd ../core
source ./setup-variables.sh
./install-dependencies.sh
./generate_td_tools.sh
./configure_td.sh
API_TYPE=legacy ./generate_tdapi_maven_project.sh
API_TYPE=legacy ./generate_tdapi_java_file.sh
API_TYPE=legacy ./build_generated_tdapi_maven_project.sh
API_TYPE=sealed ./generate_tdapi_maven_project.sh
API_TYPE=sealed ./generate_tdapi_java_file.sh
API_TYPE=sealed ./build_generated_tdapi_maven_project.sh
echo "Done."
exit 0